Discussion :

[Invité]

Bonjour, j'essaye de créer une intelligence artificielle en réseau mais j'ai quelque soucis.

Le héro et le monstre ne bougent pas bien, les animations lors de l'attaque ne se joue pas bien également.

Voici le code coté serveur :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
void MyAppli::onExec () {
        if (Network::hasRequest()) {
            User* user;
            std::string message = Network::getLastRequest(&user);
            std::vector<std::string> infos = split(message, "*");
            std::string request = infos[0];
 
            if (request == "GETCARINFOS") {
                std::ostringstream oss;
                OTextArchive oa(oss);
                Caracter* hero = static_cast<Caracter*> (World::getEntities("E_HERO")[0]);
                oa(hero);
                SymEncPacket packet;
                packet<<"CARINFOS"+oss.str();
                user->sendTcpPacket(packet);
                oss.str("");
                Caracter* monster = static_cast<Caracter*>(World::getEntities("E_MONSTER")[0]);
                oa(monster);
                packet.clear();
                packet<<"MONSTERSINFOS"+oss.str();
                user->sendTcpPacket(packet);
            } else if (request == "MOVEFROMKEYBOARD") {
                int id = conversionStringInt(infos[1]);
                Hero* hero = static_cast<Hero*> (World::getEntity(id));
                Vec2f dir (conversionStringFloat(infos[2]), conversionStringFloat(infos[3]));
                sf::Int64 last_cli_time = conversionStringLong(infos[4]);
                sf::Int64 elapsedTime = user->getClientTime() - last_cli_time;
                hero->setDir(Vec2f(dir.x, dir.y));
                hero->setMoving(true);
                hero->setIsMovingFromKeyboard(true);
                hero->setFightingMode(false);
                Vec2f actualPos = hero->getCenter();
                Vec2f newPos = actualPos + dir * hero->getSpeed() * elapsedTime;
                Vec2f d = newPos - actualPos;
                World::moveEntity(hero, d.x, d.y, 0);
            //Update the caracter states for a mouse move and update it's position from the transfer time.
            } else if (request == "MOVEFROMPATH") {
                int id = conversionStringInt(infos[1]);
                Hero* hero = static_cast<Hero*> (World::getEntity(id));
                Vec3f fPos (conversionStringInt(infos[2]), conversionStringInt(infos[3]), 0);
                std::vector<Vec2f> path = World::getPath(hero, fPos);
                hero->setPath(path);
                hero->setMoving(true);
                hero->setIsMovingFromKeyboard(false);
                hero->setFightingMode(false);
                SymEncPacket packet;
                std::string response="";
                int size = path.size();
                sf::Int64 cli_time = user->getClientTime();
                response += "NEWPATH"+conversionIntString(size)+"*"+conversionIntString(hero->getId())+"*"+conversionFloatString(hero->getCenter().x)+"*"+conversionFloatString(hero->getCenter().y)+"*"+conversionLongString(cli_time)+"*";
                for (int i = 0; i < size; i++) {
                    response += conversionFloatString(path[i].x)+"*"+conversionFloatString(path[i].y);
                    if (i != size - 1)
                        response += "*";
                }
                packet<<response;
                Network::sendTcpPacket(packet);
            //Update the path followed by the caracter. (For mouse movements)
            } else if (request == "GETCARPOS") {
                std::vector<Entity*> caracters = World::getEntities("E_MONSTER+E_HERO");
                for (unsigned int i = 0; i < caracters.size(); i++) {
                    Caracter* caracter = static_cast<Caracter*> (caracters[i]);
                    if (caracter->isMoving()) {
                        if (caracter->isMovingFromKeyboard()) {
                            Vec3f actualPos = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
                            sf::Int64 transferTime = user->getPingAvg();
                            sf::Int64 cli_time = user->getClientTime();
                            Vec3f newPos = actualPos + Vec3f(caracter->getDir().x, caracter->getDir().y, 0) * caracter->getSpeed() *  transferTime;
                            Ray ray(actualPos, newPos);
                            if (World::collide(caracter, ray)) {
                                newPos = actualPos;
                            }
                            std::string response = "NEWPOS"+conversionIntString(caracter->getId())+"*"+conversionLongString(transferTime)+"*"+conversionFloatString(newPos.x)+"*"+conversionFloatString(newPos.y)+"*"+conversionLongString(cli_time);
                            sf::Packet packet;
                            packet<<response;
                            user->sendUdpPacket(packet);
                        } else {
                            sf::Int64 transferTime = user->getPingAvg();
                            sf::Int64 cli_time = user->getClientTime();
                            Vec3f actualPos = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
                            Vec3f newPos = Computer::getPosOnPathFromTime(actualPos, caracter->getPath(), transferTime, caracter->getSpeed());
                            if (newPos.computeDist(caracter->getPath()[caracter->getPath().size() - 1]) <= 1) {
                                newPos = caracter->getPath()[caracter->getPath().size() - 1];
                            }
                            std::string response = "NEWPOS"+conversionIntString(caracter->getId())+"*"+conversionLongString(transferTime)+"*"+conversionFloatString(newPos.x)+"*"+conversionFloatString(newPos.y)+"*"+conversionLongString(cli_time);
                            sf::Packet packet;
                            packet<<response;
                            user->sendUdpPacket(packet);
                        }
                    } else {
                        sf::Int64 transferTime = user->getPingAvg();
                        sf::Int64 cli_time = user->getClientTime();
                        Vec3f newPos = caracter->getCenter();
                        std::string response = "NEWPOS"+conversionIntString(caracter->getId())+"*"+conversionLongString(transferTime)+"*"+conversionFloatString(newPos.x)+"*"+conversionFloatString(newPos.y)+"*"+conversionLongString(cli_time);
                        sf::Packet packet;
                        packet<<response;
                        user->sendUdpPacket(packet);
                    }
                }
            } else if (request == "STOPCARMOVE") {
                int id = conversionStringInt(infos[1]);
                Caracter* caracter = static_cast<Caracter*> (World::getEntity(id));
                sf::Int64 cli_time = user->getClientTime();
                if (caracter->isMoving()) {
                    sf::Int64 cli_time = conversionStringLong(infos[2]);
                    sf::Int64 delta_time = (user->getClientTime() - cli_time > 0) ? user->getClientTime() - cli_time : 0;
                    Vec3f newPos = caracter->getCenter();
                    if (caracter->isMovingFromKeyboard()) {
                        caracter->setMoving(false);
                        newPos = caracter->getCenter() - Vec3f(caracter->getDir().x, caracter->getDir().y, 0) * delta_time * caracter->getSpeed();
                        caracter->setCenter(newPos);
                    }
                    std::string response = "NEWPOS"+conversionIntString(caracter->getId())+"*"+conversionLongString(user->getPingAvg())+"*"+conversionFloatString(newPos.x)+"*"+conversionFloatString(newPos.y)+"*"+conversionLongString(cli_time);
                    SymEncPacket packet;
                    packet<<response;
                    user->sendTcpPacket(packet);
                }
            } else if (request == "ATTACK") {
                int id = conversionStringInt(infos[1]);
                Vec2f pos (conversionStringFloat(infos[2]), conversionStringFloat(infos[3]));
                sf::Int64 last_cli_time = conversionStringLong(infos[4]);
                sf::Int64 elapsedTime = user->getClientTime() - last_cli_time;
                std::vector<Entity*> monsters = World::getEntities("E_MONSTER");
                for (unsigned int i = 0; i < monsters.size(); i++) {
                    Monster* m = static_cast<Monster*>(monsters[i]);
                    sf::Int64 deltaTime;
                    bool updatePos = false;
                    if (m->isMoving()) {
                        updatePos = true;
                        deltaTime = elapsedTime;
                    } else if (!m->isMoving() && elapsedTime > m->getClkLastMove().getElapsedTime().asMicroseconds()) {
                        deltaTime = elapsedTime - (elapsedTime - m->getClkLastMove().getElapsedTime().asMicroseconds());
                        updatePos = true;
                    }
                    BoundingBox bx = m->getGlobalBounds();
                    if (updatePos) {
                        Vec2f pos = bx.getPosition();
                        Vec2f oldPos = Computer::getPosOnPathFromTime(m->getCenter(),m->getPath(),-elapsedTime,m->getSpeed());
                        Vec2f d = pos - oldPos;
                        bx.move(Vec3f(-d.x, -d.y, 0));
                    }
                    bx.setPosition(bx.getPosition().x, bx.getPosition().y, 0);
                    std::cout<<bx.getPosition()<<bx.getSize()<<pos<<std::endl;
                    if (bx.isPointInside(pos)) {
                        std::cout<<"hero in fighting mode!"<<std::endl;
                        Caracter* hero = static_cast<Caracter*>(World::getEntity(id));
                        hero->setFightingMode(true);
                        hero->setFocusedCaracter(m);
                        hero->setMoving(false);
                    }
                }
            }
        }
        /*if (getClock("LoopTime").getElapsedTime().asMilliseconds() < 100) {
            std::chrono::milliseconds dura(100 - getClock("LoopTime").getElapsedTime().asMilliseconds());
            std::this_thread::sleep_for(dura);
        }*/
        std::vector<Entity*> caracters = World::getEntities("E_HERO+E_MONSTER");
        for (unsigned int i = 0; i < caracters.size(); i++) {
            Caracter* caracter = static_cast<Caracter*>(caracters[i]);
            if (caracter->isMoving()) {
                if (caracter->isMovingFromKeyboard()) {
                    sf::Int64 elapsedTime = getClock("LoopTime").getElapsedTime().asMicroseconds();
                    Vec3f actualPos = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
                    Vec3f newPos = actualPos + Vec3f(caracter->getDir().x, caracter->getDir().y, 0) * caracter->getSpeed() * elapsedTime;
                    Ray ray(actualPos, newPos);
                    if (World::collide(caracter, ray)) {
                        newPos = actualPos;
                    }
                    Vec3f d = newPos - actualPos;
                    Vec3f dir = d.normalize();
                    if (Vec2f(dir.x, dir.y) != caracter->getDir())
                        caracter->setDir(Vec2f(dir.x, dir.y));
                    World::moveEntity(caracter, d.x, d.y, d.y);
                } else {
                    sf::Int64 elapsedTime = getClock("LoopTime").getElapsedTime().asMicroseconds();
                    Vec2f actualPos = caracter->getCenter();
                    Vec2f newPos = Computer::getPosOnPathFromTime(actualPos, caracter->getPath(), elapsedTime, caracter->getSpeed());
                    if (newPos.computeDist(caracter->getPath()[caracter->getPath().size() - 1]) <= 1) {
                        caracter->setMoving(false);
                        newPos = caracter->getPath()[caracter->getPath().size() - 1];
 
                    }
                    Vec2f d = newPos - actualPos;
                    Vec2f dir = d.normalize();
                    if (dir != caracter->getDir())
                        caracter->setDir(dir);
                    World::moveEntity(caracter, d.x, d.y, d.y);
                }
            }
            if (caracter->isInFightingMode() && !caracter->isMoving()) {
                if (caracter->getCenter().computeDist(caracter->getFocusedCaracter()->getCenter()) > caracter->getRange()) {
                    std::cout<<caracter->getType()<<" goes to ennemi!"<<std::endl;
                    std::vector<Vec2f> path = World::getPath(caracter, caracter->getFocusedCaracter()->getCenter());
                    std::string response="";
                    int size = path.size();
                    caracter->setMoving(true);
                    caracter->setPath(path);
                    caracter->setIsMovingFromKeyboard(false);
                    std::vector<User*> users = Network::getUsers();
                    for (unsigned int i = 0; i < users.size(); i++) {
                        sf::Int64 cli_time = users[i]->getClientTime();
                        response = "NEWPATH"+conversionIntString(size)+"*"+conversionIntString(caracter->getId())+"*"+conversionFloatString(caracter->getCenter().x)+"*"+conversionFloatString(caracter->getCenter().y)+"*"+conversionLongString(cli_time)+"*";
                        for (int i = 0; i < size; i++) {
                            response += conversionFloatString(path[i].x)+"*"+conversionFloatString(path[i].y);
                            if (i != size - 1)
                                response += "*";
                        }
                        SymEncPacket packet;
                        packet<<response;
                        users[i]->sendTcpPacket(packet);
                    }
                } else {
                    std::cout<<caracter->getType()<<" attack the ennemi!"<<std::endl;
                    caracter->setMoving(false);
                    caracter->attackFocusedCaracter();
                    if(dynamic_cast<Monster*>(caracter->getFocusedCaracter())) {
                        Monster* m = static_cast<Monster*>(caracter->getFocusedCaracter());
                        if (!m->isAgressif() && !m->isInFightingMode())  {
                            std::cout<<"monster is in fighting mode!"<<std::endl;
                            m->setFightingMode(true);
                            m->setFocusedCaracter(caracter);
                            m->setSavedPos(Vec3f(m->getCenter().x, m->getCenter().y, 0));
                        }
                    }
                }
            }
        }
        std::vector<Entity*> monsters = World::getEntities("E_MONSTER");
        for (unsigned int i = 0; i < monsters.size(); i++) {
            Monster* monster = static_cast<Monster*>(monsters[i]);
            if (!monster->isInFightingMode() && !monster->isMoving() && monster->getClkLastMove().getElapsedTime().asMicroseconds() >= monster->getTimeUntilNextMove().asMicroseconds()) {
                std::cout<<"monster is moving to a new localisation"<<std::endl;
                Vec3f finalPos;
                do {
                    finalPos = monster->respawn();
                } while (World::collide(monster, finalPos));
                std::vector<Vec2f> path = World::getPath(monster, finalPos);
                monster->setPath(path);
                monster->setMoving(true);
                sf::Time time1 = monster->getMoveTimeInterval1();
                sf::Time time2 = monster->getMoveTimeInterval2();
                sf::Time time3 = sf::seconds(Math::random(time1.asSeconds(), time2.asSeconds()));
                monster->setTimeUntilNextMove(time3);
                monster->getClkLastMove().restart();
                std::vector<User*> users = Network::getUsers();
                for (unsigned int i = 0; i < users.size(); i++) {
                    std::string response="";
                    int size = path.size();
                    sf::Int64 cli_time = users[i]->getClientTime();
                    response = "NEWPATH"+conversionIntString(size)+"*"+conversionIntString(monster->getId())+"*"+conversionFloatString(monster->getCenter().x)+"*"+conversionFloatString(monster->getCenter().y)+"*"+conversionLongString(cli_time)+"*";
                    for (int i = 0; i < size; i++) {
                        response += conversionFloatString(path[i].x)+"*"+conversionFloatString(path[i].y);
                        if (i != size - 1)
                            response += "*";
                    }
                    SymEncPacket packet;
                    packet<<response;
                    users[i]->sendTcpPacket(packet);
                }
            } else if (monster->isInFightingMode() && !monster->getZone().isPointInside(Vec3f(monster->getCenter().x, monster->getCenter().y, 0))) {
                std::cout<<"monster goes back"<<std::endl;
                std::vector<Vec2f> path = World::getPath(monster, monster->getSavedPos());
                monster->setPath(path);
                monster->setMoving(true);
                monster->setFightingMode(false);
                std::vector<User*> users = Network::getUsers();
                for (unsigned int i = 0; i < users.size(); i++) {
                    std::string response="";
                    int size = path.size();
                    sf::Int64 cli_time = users[i]->getClientTime();
                    response = "NEWPATH"+conversionIntString(size)+"*"+conversionIntString(monster->getId())+"*"+conversionFloatString(monster->getCenter().x)+"*"+conversionFloatString(monster->getCenter().y)+"*"+conversionLongString(cli_time)+"*";
                    for (int i = 0; i < size; i++) {
                        response += conversionFloatString(path[i].x)+"*"+conversionFloatString(path[i].y);
                        if (i != size - 1)
                            response += "*";
                    }
                    SymEncPacket packet;
                    packet<<response;
                    users[i]->sendTcpPacket(packet);
                }
            }
        }
    }
}

Et côté client :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
void MyAppli::onExec () {
        if (getClock("RequestTime").getElapsedTime().asSeconds() >= timeBtwnTwoReq.asSeconds()) {
            std::string request = "GETCARPOS";
            sf::Packet packet;
            packet<<request;
            Network::sendUdpPacket(packet);
            getClock("RequestTime").restart();
        }
        std::string response;
        if (Network::getResponse("NEWPATH", response)) {
            std::vector<std::string> infos = split(response, "*");
            std::vector<Vec2f> path;
            int size = conversionStringInt(infos[0]);
            int id = conversionStringInt(infos[1]);
            Caracter* caracter = static_cast<Caracter*>(World::getEntity(id));
            Vec2f actualPos (conversionStringFloat(infos[2]), conversionStringFloat(infos[3]));
            sf::Int64 last_cli_time = conversionStringLong(infos[4]);
            sf::Int64 elapsedTime = Application::getTimeClk().getElapsedTime().asMicroseconds() - last_cli_time;
            Vec2f newPos = Computer::getPosOnPathFromTime(actualPos, caracter->getPath(),elapsedTime,caracter->getSpeed());
            for (int i = 0; i < size; i++) {
                path.push_back(Vec2f(conversionStringFloat(infos[i*2+5]), conversionStringFloat(infos[i*2+6])));
            }
            Vec2f d = newPos - actualPos;
            if (id == hero->getId()) {
                for (unsigned int i = 0; i < getRenderComponentManager().getNbComponents(); i++) {
                    View view = getRenderComponentManager().getRenderComponent(i)->getView();
                    view.move(d.x, d.y, d.y);
                    getRenderComponentManager().getRenderComponent(i)->setView(view);
                }
                getView().move (d.x, d.y, d.y);
            }
            Vec2f dir = d.normalize();
            if (dir != caracter->getDir())
                caracter->setDir(dir);
            World::moveEntity(caracter, d.x, d.y, d.y);
            caracter->setPath(path);
            caracter->setMoving(true);
            caracter->interpolation.first = caracter->getCenter();
            caracter->interpolation.second = Computer::getPosOnPathFromTime(caracter->interpolation.first, caracter->getPath(),ping + timeBtwnTwoReq.asMicroseconds(),caracter->getSpeed());
            caracter->getClkTransfertTime().restart();
        }
        if (Network::getResponse("NEWPOS", response)) {
            std::vector<std::string> infos = split(response, "*");
            int id = conversionStringInt(infos[0]);
            ping = conversionStringLong(infos[1]);
            Caracter* caracter = static_cast<Caracter*>(World::getEntity(id));
            Vec3f actualPos = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
            Vec3f newPos (conversionStringFloat(infos[2]), conversionStringFloat(infos[3]), 0);
            sf::Int64 last_cli_time = conversionStringLong(infos[4]);
            sf::Int64 elapsedTime = Application::getTimeClk().getElapsedTime().asMicroseconds() - last_cli_time;
            if (caracter->isMovingFromKeyboard()) {
                newPos = newPos + Vec3f(caracter->getDir().x, caracter->getDir().y, 0) * caracter->getSpeed() * elapsedTime;
            } else {
                newPos = Computer::getPosOnPathFromTime(newPos, caracter->getPath(),elapsedTime, caracter->getSpeed());
            }
            Vec3f d = newPos - actualPos;
            if (id == hero->getId()) {
                for (unsigned int i = 0; i < getRenderComponentManager().getNbComponents(); i++) {
                    View view = getRenderComponentManager().getRenderComponent(i)->getView();
                    view.move(d.x, d.y, d.y);
                    getRenderComponentManager().getRenderComponent(i)->setView(view);
                }
                getView().move (d.x, d.y, d.y);
            }
            World::moveEntity(caracter, d.x, d.y, d.y);
            World::update();
            caracter->interpolation.first = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
            if (caracter->isMoving()) {
                if (caracter->isMovingFromKeyboard()) {
                    caracter->interpolation.second = caracter->interpolation.first + Vec3f(caracter->getDir().x,caracter->getDir().y,0)  * caracter->getSpeed() * (ping + timeBtwnTwoReq.asMicroseconds());
                } else {
                    caracter->interpolation.second = Computer::getPosOnPathFromTime(caracter->interpolation.first, caracter->getPath(),ping + timeBtwnTwoReq.asMicroseconds(),caracter->getSpeed());
                }
            } else {
                caracter->interpolation.second = caracter->interpolation.first;
            }
            caracter->getClkTransfertTime().restart();
       }
       std::vector<Entity*> caracters = World::getEntities("E_MONSTER+E_HERO");
       for (unsigned int i = 0; i < caracters.size(); i++) {
            Caracter* caracter = static_cast<Caracter*>(caracters[i]);
            if (caracter->isMoving()) {
                if (caracter->isMovingFromKeyboard()) {
                    Vec3f actualPos = Vec3f(caracter->getCenter().x, caracter->getCenter().y, 0);
                    sf::Int64 elapsedTime = caracter->getClkTransfertTime().getElapsedTime().asMicroseconds();
                    Vec3f newPos = caracter->interpolation.first + (caracter->interpolation.second - caracter->interpolation.first) * ((float) elapsedTime / (float) (ping + timeBtwnTwoReq.asMicroseconds()));
                    Ray ray(actualPos, newPos);
                    if (World::collide(caracter, ray)) {
                        newPos = actualPos;
                    }
                    for (unsigned int i = 0; i < getRenderComponentManager().getNbComponents(); i++) {
                        View view = getRenderComponentManager().getRenderComponent(i)->getView();
                        Vec3f d = newPos - view.getPosition();
                        view.move(d.x, d.y, d.y);
                        getRenderComponentManager().getRenderComponent(i)->setView(view);
                    }
                    Vec3f d = newPos - actualPos;
                    World::moveEntity(caracter, d.x, d.y, d.y);
                    getView().move(d.x, d.y, d.y);
                    World::update();
                } else {
                    Vec3f actualPos (caracter->getCenter().x, caracter->getCenter().y, 0);
                    sf::Int64 elapsedTime = caracter->getClkTransfertTime().getElapsedTime().asMicroseconds();
                    Vec3f newPos = caracter->interpolation.first + (caracter->interpolation.second - caracter->interpolation.first) * ((float) elapsedTime / (float) (ping + timeBtwnTwoReq.asMicroseconds()));
                    Vec3f d = newPos - actualPos;
                    if (newPos.computeDist(caracter->getPath()[caracter->getPath().size() - 1]) <= 1) {
                        caracter->setMoving(false);
                        newPos = caracter->getPath()[caracter->getPath().size() - 1];
                    }
                    if (caracter->getId() == hero->getId()) {
                        for (unsigned int i = 0; i < getRenderComponentManager().getNbComponents(); i++) {
                            View view = getRenderComponentManager().getRenderComponent(i)->getView();
                            view.move(d.x, d.y, d.y);
                            getRenderComponentManager().getRenderComponent(i)->setView(view);
                        }
                        getView().move(d.x, d.y, d.y);
                    }
                    Vec2f dir = d.normalize();
                    if (dir != caracter->getDir())
                        caracter->setDir(dir);
                    World::moveEntity(caracter, d.x, d.y, d.y);
                    World::update();
                }
            }
            if (caracter->getFocusedCaracter() != nullptr && caracter->isInFightingMode() && caracter->getCenter().computeDist(caracter->getFocusedCaracter()->getCenter()) <= caracter->getRange()) {
                caracter->setMoving(false);
                if (dynamic_cast<Monster*>(caracter->getFocusedCaracter())) {
                    caracter->getFocusedCaracter()->setFightingMode(true);
                    caracter->getFocusedCaracter()->setAttacking(true);
                }
                caracter->setAttacking(true);
                caracter->attackFocusedCaracter();
            } else {
                caracter->setAttacking(false);
            }
        }
    }

N'y a t'il pas un site ou je pourrai dénicher quelque code source sur l'implémentation d'une intelligence artificielle dans un mmorpg ?

Merci d'avance.

[Mat.M]

salut déjà
1-il faut démarrer un "background thread" , un thread qui tourne en tâche de fond pour gérer les messages du client vers serveur et vice-versa
quoiqu'on peut créer des sockets et faire appel à des fonctions réseaux non bloquantes

2-ensuite moi ce que j'ai fait ( (j'ai programmé mon jeu de poste à poste avec un câble de liaison et non comme client-serveur je n'ai pas payé pour un serveur en ligne ) , si le joueur A clique sur l'écran pour faire déplacer un perso, le client A envoie un message vers le client B , le client B le reçoit et traite le message, il comprend que c'est "déplace entité numéro 10 point 150,200" et appel du code pour déplacer le perso.
Ensuite comment est la topologie du jeu ? As-tu un accès serveur avec socket ?
Si c'est du client-serveur , c'est pareil le serveur doit dispatcher les messages vers les autres clients ; si tu déplaces un personnage A de ton côté, le serveur reçoit le message et le redistribue vers les autres clients afin que les autres clients répercutent l'action

[Invité]

C'est bon j'ai réussi.
RESOLU.

PS : je n'ai plus qu'à gérer les morts et le système d'xp.