?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' into main/rendor-staging
[ryzomcore.git] / ryzom / common / src / game_share / r2_share_itf.cpp
blob2c8b99dfa1dc06f44d142366148cc9b88ccea053
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 /////////////////////////////////////////////////////////////////
18 // WARNING : this is a generated file, don't change it !
19 /////////////////////////////////////////////////////////////////
20
21 #include "stdpch.h"
22
23 #include "r2_share_itf.h"
24
25 namespace R2
26 {
27
28 /////////////////////////////////////////////////////////////////
29 // WARNING : this is a generated file, don't change it !
30 /////////////////////////////////////////////////////////////////
31
32
33 const CShareServerAnimationItfSkel::TMessageHandlerMap &CShareServerAnimationItfSkel::getMessageHandlers() const
34 {
35 static TMessageHandlerMap handlers;
36 static bool init = false;
37
38 if (!init)
39 {
40 std::pair < TMessageHandlerMap::iterator, bool > res;
41
42 res = handlers.insert(std::make_pair(std::string("RCAMP"), &CShareServerAnimationItfSkel::connectAnimationModePlay_skel));
43 // if this assert, you have a doubly message name in your interface definition !
44 nlassert(res.second);
45
46 res = handlers.insert(std::make_pair(std::string("SAID"), &CShareServerAnimationItfSkel::askMissionItemsDescription_skel));
47 // if this assert, you have a doubly message name in your interface definition !
48 nlassert(res.second);
49
50 res = handlers.insert(std::make_pair(std::string("SAAPD"), &CShareServerAnimationItfSkel::askActPositionDescriptions_skel));
51 // if this assert, you have a doubly message name in your interface definition !
52 nlassert(res.second);
53
54 res = handlers.insert(std::make_pair(std::string("SAUTD"), &CShareServerAnimationItfSkel::askUserTriggerDescriptions_skel));
55 // if this assert, you have a doubly message name in your interface definition !
56 nlassert(res.second);
57
58 res = handlers.insert(std::make_pair(std::string("SOUTT"), &CShareServerAnimationItfSkel::onUserTriggerTriggered_skel));
59 // if this assert, you have a doubly message name in your interface definition !
60 nlassert(res.second);
61
62 res = handlers.insert(std::make_pair(std::string("SODT"), &CShareServerAnimationItfSkel::onDssTarget_skel));
63 // if this assert, you have a doubly message name in your interface definition !
64 nlassert(res.second);
65
66 init = true;
67 }
68
69 return handlers;
70 }
71 bool CShareServerAnimationItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
72 {
73 const TMessageHandlerMap &mh = getMessageHandlers();
74
75 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
76
77 if (it == mh.end())
78 {
79 return false;
80 }
81
82 TMessageHandler cmd = it->second;
83 (this->*cmd)(sender, message);
84
85 return true;
86 }
87
88
89 void CShareServerAnimationItfSkel::connectAnimationModePlay_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
90 {
91 H_AUTO(CShareServerAnimationItfSkel_connectAnimationModePlay_RCAMP);
92 connectAnimationModePlay(sender);
93 }
94
95 void CShareServerAnimationItfSkel::askMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
96 {
97 H_AUTO(CShareServerAnimationItfSkel_askMissionItemsDescription_SAID);
98 askMissionItemsDescription(sender);
99 }
100
101 void CShareServerAnimationItfSkel::askActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
102 {
103 H_AUTO(CShareServerAnimationItfSkel_askActPositionDescriptions_SAAPD);
104 askActPositionDescriptions(sender);
105 }
106
107 void CShareServerAnimationItfSkel::askUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
108 {
109 H_AUTO(CShareServerAnimationItfSkel_askUserTriggerDescriptions_SAUTD);
110 askUserTriggerDescriptions(sender);
111 }
112
113 void CShareServerAnimationItfSkel::onUserTriggerTriggered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
114 {
115 H_AUTO(CShareServerAnimationItfSkel_onUserTriggerTriggered_SOUTT);
116 uint32 actId;
117 nlRead(__message, serial, actId);
118 uint32 triggerId;
119 nlRead(__message, serial, triggerId);
120 onUserTriggerTriggered(sender, actId, triggerId);
121 }
122
123 void CShareServerAnimationItfSkel::onDssTarget_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
124 {
125 H_AUTO(CShareServerAnimationItfSkel_onDssTarget_SODT);
126 std::vector<std::string> args;
127 nlRead(__message, serialCont, args);
128 onDssTarget(sender, args);
129 }
130 // request the connection to play mode in an animation session
131 void CShareServerAnimationItfProxy::connectAnimationModePlay(NLNET::IModule *sender)
132 {
133 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
134 {
135 // immediate local synchronous dispatching
136 _LocalModuleSkel->connectAnimationModePlay(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
137 }
138 else
139 {
140 // send the message for remote dispatching and execution or local queing
141 NLNET::CMessage __message;
142
143 buildMessageFor_connectAnimationModePlay(__message);
144
145 _ModuleProxy->sendModuleMessage(sender, __message);
146 }
147 }
148 // A client Message to register mission item of a scenario
149 void CShareServerAnimationItfProxy::askMissionItemsDescription(NLNET::IModule *sender)
150 {
151 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
152 {
153 // immediate local synchronous dispatching
154 _LocalModuleSkel->askMissionItemsDescription(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
155 }
156 else
157 {
158 // send the message for remote dispatching and execution or local queing
159 NLNET::CMessage __message;
160
161 buildMessageFor_askMissionItemsDescription(__message);
162
163 _ModuleProxy->sendModuleMessage(sender, __message);
164 }
165 }
166 // A client Message to update client Act Position Description
167 void CShareServerAnimationItfProxy::askActPositionDescriptions(NLNET::IModule *sender)
168 {
169 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
170 {
171 // immediate local synchronous dispatching
172 _LocalModuleSkel->askActPositionDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
173 }
174 else
175 {
176 // send the message for remote dispatching and execution or local queing
177 NLNET::CMessage __message;
178
179 buildMessageFor_askActPositionDescriptions(__message);
180
181 _ModuleProxy->sendModuleMessage(sender, __message);
182 }
183 }
184 // A client Message to update client User Trigger Description
185 void CShareServerAnimationItfProxy::askUserTriggerDescriptions(NLNET::IModule *sender)
186 {
187 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
188 {
189 // immediate local synchronous dispatching
190 _LocalModuleSkel->askUserTriggerDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
191 }
192 else
193 {
194 // send the message for remote dispatching and execution or local queing
195 NLNET::CMessage __message;
196
197 buildMessageFor_askUserTriggerDescriptions(__message);
198
199 _ModuleProxy->sendModuleMessage(sender, __message);
200 }
201 }
202 // client wants to trigger an user trigger
203 void CShareServerAnimationItfProxy::onUserTriggerTriggered(NLNET::IModule *sender, uint32 actId, uint32 triggerId)
204 {
205 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
206 {
207 // immediate local synchronous dispatching
208 _LocalModuleSkel->onUserTriggerTriggered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actId, triggerId);
209 }
210 else
211 {
212 // send the message for remote dispatching and execution or local queing
213 NLNET::CMessage __message;
214
215 buildMessageFor_onUserTriggerTriggered(__message, actId, triggerId);
216
217 _ModuleProxy->sendModuleMessage(sender, __message);
218 }
219 }
220 // client wants to execute a dm action on its target
221 void CShareServerAnimationItfProxy::onDssTarget(NLNET::IModule *sender, const std::vector<std::string> &args)
222 {
223 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
224 {
225 // immediate local synchronous dispatching
226 _LocalModuleSkel->onDssTarget(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), args);
227 }
228 else
229 {
230 // send the message for remote dispatching and execution or local queing
231 NLNET::CMessage __message;
232
233 buildMessageFor_onDssTarget(__message, args);
234
235 _ModuleProxy->sendModuleMessage(sender, __message);
236 }
237 }
238
239 // Message serializer. Return the message received in reference for easier integration
240 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_connectAnimationModePlay(NLNET::CMessage &__message)
241 {
242 __message.setType("RCAMP");
243
244
245 return __message;
246 }
247
248 // Message serializer. Return the message received in reference for easier integration
249 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askMissionItemsDescription(NLNET::CMessage &__message)
250 {
251 __message.setType("SAID");
252
253
254 return __message;
255 }
256
257 // Message serializer. Return the message received in reference for easier integration
258 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askActPositionDescriptions(NLNET::CMessage &__message)
259 {
260 __message.setType("SAAPD");
261
262
263 return __message;
264 }
265
266 // Message serializer. Return the message received in reference for easier integration
267 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askUserTriggerDescriptions(NLNET::CMessage &__message)
268 {
269 __message.setType("SAUTD");
270
271
272 return __message;
273 }
274
275 // Message serializer. Return the message received in reference for easier integration
276 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_onUserTriggerTriggered(NLNET::CMessage &__message, uint32 actId, uint32 triggerId)
277 {
278 __message.setType("SOUTT");
279 nlWrite(__message, serial, actId);
280 nlWrite(__message, serial, triggerId);
281
282
283 return __message;
284 }
285
286 // Message serializer. Return the message received in reference for easier integration
287 const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_onDssTarget(NLNET::CMessage &__message, const std::vector<std::string> &args)
288 {
289 __message.setType("SODT");
290 nlWrite(__message, serialCont, const_cast < std::vector<std::string>& > (args));
291
292
293 return __message;
294 }
295
296 /////////////////////////////////////////////////////////////////
297 // WARNING : this is a generated file, don't change it !
298 /////////////////////////////////////////////////////////////////
299
300
301 const CShareServerEditionItfSkel::TMessageHandlerMap &CShareServerEditionItfSkel::getMessageHandlers() const
302 {
303 static TMessageHandlerMap handlers;
304 static bool init = false;
305
306 if (!init)
307 {
308 std::pair < TMessageHandlerMap::iterator, bool > res;
309
310 res = handlers.insert(std::make_pair(std::string("RSS1"), &CShareServerEditionItfSkel::startingScenario_skel));
311 // if this assert, you have a doubly message name in your interface definition !
312 nlassert(res.second);
313
314 res = handlers.insert(std::make_pair(std::string("RSS2"), &CShareServerEditionItfSkel::startScenario_skel));
315 // if this assert, you have a doubly message name in your interface definition !
316 nlassert(res.second);
317
318 res = handlers.insert(std::make_pair(std::string("ADC_ACK"), &CShareServerEditionItfSkel::advConnACK_skel));
319 // if this assert, you have a doubly message name in your interface definition !
320 nlassert(res.second);
321
322 res = handlers.insert(std::make_pair(std::string("SUCR"), &CShareServerEditionItfSkel::onUserComponentRegistered_skel));
323 // if this assert, you have a doubly message name in your interface definition !
324 nlassert(res.second);
325
326 res = handlers.insert(std::make_pair(std::string("SUCD"), &CShareServerEditionItfSkel::onUserComponentDownloading_skel));
327 // if this assert, you have a doubly message name in your interface definition !
328 nlassert(res.second);
329
330 res = handlers.insert(std::make_pair(std::string("SSUA"), &CShareServerEditionItfSkel::onScenarioUploadAsked_skel));
331 // if this assert, you have a doubly message name in your interface definition !
332 nlassert(res.second);
333
334 res = handlers.insert(std::make_pair(std::string("SNSA"), &CShareServerEditionItfSkel::onNodeSetAsked_skel));
335 // if this assert, you have a doubly message name in your interface definition !
336 nlassert(res.second);
337
338 res = handlers.insert(std::make_pair(std::string("SNIA"), &CShareServerEditionItfSkel::onNodeInsertAsked_skel));
339 // if this assert, you have a doubly message name in your interface definition !
340 nlassert(res.second);
341
342 res = handlers.insert(std::make_pair(std::string("SNEA"), &CShareServerEditionItfSkel::onNodeEraseAsked_skel));
343 // if this assert, you have a doubly message name in your interface definition !
344 nlassert(res.second);
345
346 res = handlers.insert(std::make_pair(std::string("SNMA"), &CShareServerEditionItfSkel::onNodeMoveAsked_skel));
347 // if this assert, you have a doubly message name in your interface definition !
348 nlassert(res.second);
349
350 res = handlers.insert(std::make_pair(std::string("SMCA"), &CShareServerEditionItfSkel::onMapConnectionAsked_skel));
351 // if this assert, you have a doubly message name in your interface definition !
352 nlassert(res.second);
353
354 res = handlers.insert(std::make_pair(std::string("SCMUA"), &CShareServerEditionItfSkel::onCharModeUpdateAsked_skel));
355 // if this assert, you have a doubly message name in your interface definition !
356 nlassert(res.second);
357
358 res = handlers.insert(std::make_pair(std::string("STPA"), &CShareServerEditionItfSkel::onTpPositionAsked_skel));
359 // if this assert, you have a doubly message name in your interface definition !
360 nlassert(res.second);
361
362 res = handlers.insert(std::make_pair(std::string("TPEP"), &CShareServerEditionItfSkel::tpToEntryPoint_skel));
363 // if this assert, you have a doubly message name in your interface definition !
364 nlassert(res.second);
365
366 res = handlers.insert(std::make_pair(std::string("STA"), &CShareServerEditionItfSkel::setStartingAct_skel));
367 // if this assert, you have a doubly message name in your interface definition !
368 nlassert(res.second);
369
370 res = handlers.insert(std::make_pair(std::string("SRAU"), &CShareServerEditionItfSkel::onScenarioRingAccessUpdated_skel));
371 // if this assert, you have a doubly message name in your interface definition !
372 nlassert(res.second);
373
374 res = handlers.insert(std::make_pair(std::string("SSSFA"), &CShareServerEditionItfSkel::saveScenarioFile_skel));
375 // if this assert, you have a doubly message name in your interface definition !
376 nlassert(res.second);
377
378 res = handlers.insert(std::make_pair(std::string("SLSFA"), &CShareServerEditionItfSkel::loadScenarioFile_skel));
379 // if this assert, you have a doubly message name in your interface definition !
380 nlassert(res.second);
381
382 res = handlers.insert(std::make_pair(std::string("SUCF"), &CShareServerEditionItfSkel::saveUserComponentFile_skel));
383 // if this assert, you have a doubly message name in your interface definition !
384 nlassert(res.second);
385
386 res = handlers.insert(std::make_pair(std::string("LUCF"), &CShareServerEditionItfSkel::loadUserComponentFile_skel));
387 // if this assert, you have a doubly message name in your interface definition !
388 nlassert(res.second);
389
390 res = handlers.insert(std::make_pair(std::string("STOCTA"), &CShareServerEditionItfSkel::teleportOneCharacterToAnother_skel));
391 // if this assert, you have a doubly message name in your interface definition !
392 nlassert(res.second);
393
394 res = handlers.insert(std::make_pair(std::string("STWUS"), &CShareServerEditionItfSkel::teleportWhileUploadingScenario_skel));
395 // if this assert, you have a doubly message name in your interface definition !
396 nlassert(res.second);
397
398 res = handlers.insert(std::make_pair(std::string("DSS_HEAD"), &CShareServerEditionItfSkel::multiPartMsgHead_skel));
399 // if this assert, you have a doubly message name in your interface definition !
400 nlassert(res.second);
401
402 res = handlers.insert(std::make_pair(std::string("DSS_MSG"), &CShareServerEditionItfSkel::multiPartMsgBody_skel));
403 // if this assert, you have a doubly message name in your interface definition !
404 nlassert(res.second);
405
406 res = handlers.insert(std::make_pair(std::string("DSS_FOOT"), &CShareServerEditionItfSkel::multiPartMsgFoot_skel));
407 // if this assert, you have a doubly message name in your interface definition !
408 nlassert(res.second);
409
410 res = handlers.insert(std::make_pair(std::string("DSS_FW"), &CShareServerEditionItfSkel::forwardToDss_skel));
411 // if this assert, you have a doubly message name in your interface definition !
412 nlassert(res.second);
413
414 init = true;
415 }
416
417 return handlers;
418 }
419 bool CShareServerEditionItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
420 {
421 const TMessageHandlerMap &mh = getMessageHandlers();
422
423 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
424
425 if (it == mh.end())
426 {
427 return false;
428 }
429
430 TMessageHandler cmd = it->second;
431 (this->*cmd)(sender, message);
432
433 return true;
434 }
435
436
437 void CShareServerEditionItfSkel::startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
438 {
439 H_AUTO(CShareServerEditionItfSkel_startingScenario_RSS1);
440 startingScenario(sender);
441 }
442
443 void CShareServerEditionItfSkel::startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
444 {
445 H_AUTO(CShareServerEditionItfSkel_startScenario_RSS2);
446 bool ok;
447 nlRead(__message, serial, ok);
448 TScenarioHeaderSerializer header;
449 nlRead(__message, serial, header);
450 CObjectSerializerServer data;
451 nlRead(__message, serial, data);
452 uint32 startingAct;
453 nlRead(__message, serial, startingAct);
454 startScenario(sender, ok, header, data, startingAct);
455 }
456
457 void CShareServerEditionItfSkel::advConnACK_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
458 {
459 H_AUTO(CShareServerEditionItfSkel_advConnACK_ADC_ACK);
460 advConnACK(sender);
461 }
462
463 void CShareServerEditionItfSkel::onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
464 {
465 H_AUTO(CShareServerEditionItfSkel_onUserComponentRegistered_SUCR);
466 NLMISC::CHashKeyMD5 md5;
467 nlRead(__message, serial, md5);
468 onUserComponentRegistered(sender, md5);
469 }
470
471 void CShareServerEditionItfSkel::onUserComponentDownloading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
472 {
473 H_AUTO(CShareServerEditionItfSkel_onUserComponentDownloading_SUCD);
474 NLMISC::CHashKeyMD5 md5;
475 nlRead(__message, serial, md5);
476 onUserComponentDownloading(sender, md5);
477 }
478
479 void CShareServerEditionItfSkel::onScenarioUploadAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
480 {
481 H_AUTO(CShareServerEditionItfSkel_onScenarioUploadAsked_SSUA);
482 uint32 msgId;
483 nlRead(__message, serial, msgId);
484 CObjectSerializerServer hlScenario;
485 nlRead(__message, serial, hlScenario);
486 bool mustBrodcast;
487 nlRead(__message, serial, mustBrodcast);
488 onScenarioUploadAsked(sender, msgId, hlScenario, mustBrodcast);
489 }
490
491 void CShareServerEditionItfSkel::onNodeSetAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
492 {
493 H_AUTO(CShareServerEditionItfSkel_onNodeSetAsked_SNSA);
494 uint32 msgId;
495 nlRead(__message, serial, msgId);
496 std::string instanceId;
497 nlRead(__message, serial, instanceId);
498 std::string attrName;
499 nlRead(__message, serial, attrName);
500 R2::CObjectSerializerServer value;
501 nlRead(__message, serial, value);
502 onNodeSetAsked(sender, msgId, instanceId, attrName, value);
503 }
504
505 void CShareServerEditionItfSkel::onNodeInsertAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
506 {
507 H_AUTO(CShareServerEditionItfSkel_onNodeInsertAsked_SNIA);
508 uint32 msgId;
509 nlRead(__message, serial, msgId);
510 std::string instanceId;
511 nlRead(__message, serial, instanceId);
512 std::string attrName;
513 nlRead(__message, serial, attrName);
514 sint32 position;
515 nlRead(__message, serial, position);
516 std::string key;
517 nlRead(__message, serial, key);
518 R2::CObjectSerializerServer value;
519 nlRead(__message, serial, value);
520 onNodeInsertAsked(sender, msgId, instanceId, attrName, position, key, value);
521 }
522
523 void CShareServerEditionItfSkel::onNodeEraseAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
524 {
525 H_AUTO(CShareServerEditionItfSkel_onNodeEraseAsked_SNEA);
526 uint32 msgId;
527 nlRead(__message, serial, msgId);
528 std::string instanceId;
529 nlRead(__message, serial, instanceId);
530 std::string attrName;
531 nlRead(__message, serial, attrName);
532 sint32 position;
533 nlRead(__message, serial, position);
534 onNodeEraseAsked(sender, msgId, instanceId, attrName, position);
535 }
536
537 void CShareServerEditionItfSkel::onNodeMoveAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
538 {
539 H_AUTO(CShareServerEditionItfSkel_onNodeMoveAsked_SNMA);
540 uint32 msgId;
541 nlRead(__message, serial, msgId);
542 std::string instanceId1;
543 nlRead(__message, serial, instanceId1);
544 std::string attrName1;
545 nlRead(__message, serial, attrName1);
546 sint32 position1;
547 nlRead(__message, serial, position1);
548 std::string instanceId2;
549 nlRead(__message, serial, instanceId2);
550 std::string attrName2;
551 nlRead(__message, serial, attrName2);
552 sint32 position2;
553 nlRead(__message, serial, position2);
554 onNodeMoveAsked(sender, msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2);
555 }
556
557 void CShareServerEditionItfSkel::onMapConnectionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
558 {
559 H_AUTO(CShareServerEditionItfSkel_onMapConnectionAsked_SMCA);
560 TSessionId scenarioId;
561 nlRead(__message, serial, scenarioId);
562 bool updateHighLevel;
563 nlRead(__message, serial, updateHighLevel);
564 bool mustTp;
565 nlRead(__message, serial, mustTp);
566 R2::TUserRole role;
567 nlRead(__message, serial, role);
568 onMapConnectionAsked(sender, scenarioId, updateHighLevel, mustTp, role);
569 }
570
571 void CShareServerEditionItfSkel::onCharModeUpdateAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
572 {
573 H_AUTO(CShareServerEditionItfSkel_onCharModeUpdateAsked_SCMUA);
574 R2::TCharMode mode;
575 nlRead(__message, serial, mode);
576 onCharModeUpdateAsked(sender, mode);
577 }
578
579 void CShareServerEditionItfSkel::onTpPositionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
580 {
581 H_AUTO(CShareServerEditionItfSkel_onTpPositionAsked_STPA);
582 float x;
583 nlRead(__message, serial, x);
584 float y;
585 nlRead(__message, serial, y);
586 float z;
587 nlRead(__message, serial, z);
588 onTpPositionAsked(sender, x, y, z);
589 }
590
591 void CShareServerEditionItfSkel::tpToEntryPoint_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
592 {
593 H_AUTO(CShareServerEditionItfSkel_tpToEntryPoint_TPEP);
594 uint32 actIndex;
595 nlRead(__message, serial, actIndex);
596 tpToEntryPoint(sender, actIndex);
597 }
598
599 void CShareServerEditionItfSkel::setStartingAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
600 {
601 H_AUTO(CShareServerEditionItfSkel_setStartingAct_STA);
602 uint32 actIndex;
603 nlRead(__message, serial, actIndex);
604 setStartingAct(sender, actIndex);
605 }
606
607 void CShareServerEditionItfSkel::onScenarioRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
608 {
609 H_AUTO(CShareServerEditionItfSkel_onScenarioRingAccessUpdated_SRAU);
610 bool ok;
611 nlRead(__message, serial, ok);
612 std::string ringAccess;
613 nlRead(__message, serial, ringAccess);
614 std::string errMsg;
615 nlRead(__message, serial, errMsg);
616 onScenarioRingAccessUpdated(sender, ok, ringAccess, errMsg);
617 }
618
619 void CShareServerEditionItfSkel::saveScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
620 {
621 H_AUTO(CShareServerEditionItfSkel_saveScenarioFile_SSSFA);
622 std::string md5;
623 nlRead(__message, serial, md5);
624 R2::TScenarioHeaderSerializer header;
625 nlRead(__message, serial, header);
626 saveScenarioFile(sender, md5, header);
627 }
628
629 void CShareServerEditionItfSkel::loadScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
630 {
631 H_AUTO(CShareServerEditionItfSkel_loadScenarioFile_SLSFA);
632 std::string md5;
633 nlRead(__message, serial, md5);
634 std::string signature;
635 nlRead(__message, serial, signature);
636 loadScenarioFile(sender, md5, signature);
637 }
638
639 void CShareServerEditionItfSkel::saveUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
640 {
641 H_AUTO(CShareServerEditionItfSkel_saveUserComponentFile_SUCF);
642 std::string md5;
643 nlRead(__message, serial, md5);
644 R2::TScenarioHeaderSerializer header;
645 nlRead(__message, serial, header);
646 saveUserComponentFile(sender, md5, header);
647 }
648
649 void CShareServerEditionItfSkel::loadUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
650 {
651 H_AUTO(CShareServerEditionItfSkel_loadUserComponentFile_LUCF);
652 std::string md5;
653 nlRead(__message, serial, md5);
654 std::string signature;
655 nlRead(__message, serial, signature);
656 loadUserComponentFile(sender, md5, signature);
657 }
658
659 void CShareServerEditionItfSkel::teleportOneCharacterToAnother_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
660 {
661 H_AUTO(CShareServerEditionItfSkel_teleportOneCharacterToAnother_STOCTA);
662 TSessionId sessionId;
663 nlRead(__message, serial, sessionId);
664 uint32 sourceId;
665 nlRead(__message, serial, sourceId);
666 uint32 destId;
667 nlRead(__message, serial, destId);
668 teleportOneCharacterToAnother(sender, sessionId, sourceId, destId);
669 }
670
671 void CShareServerEditionItfSkel::teleportWhileUploadingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
672 {
673 H_AUTO(CShareServerEditionItfSkel_teleportWhileUploadingScenario_STWUS);
674 std::string island;
675 nlRead(__message, serial, island);
676 std::string entryPoint;
677 nlRead(__message, serial, entryPoint);
678 std::string season;
679 nlRead(__message, serial, season);
680 teleportWhileUploadingScenario(sender, island, entryPoint, season);
681 }
682
683 void CShareServerEditionItfSkel::multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
684 {
685 H_AUTO(CShareServerEditionItfSkel_multiPartMsgHead_DSS_HEAD);
686 uint32 charId;
687 nlRead(__message, serial, charId);
688 std::string msgName;
689 nlRead(__message, serial, msgName);
690 uint32 nbPacket;
691 nlRead(__message, serial, nbPacket);
692 uint32 size;
693 nlRead(__message, serial, size);
694 multiPartMsgHead(sender, charId, msgName, nbPacket, size);
695 }
696
697 void CShareServerEditionItfSkel::multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
698 {
699 H_AUTO(CShareServerEditionItfSkel_multiPartMsgBody_DSS_MSG);
700 uint32 charId;
701 nlRead(__message, serial, charId);
702 uint32 partId;
703 nlRead(__message, serial, partId);
704 std::vector<uint8> data;
705 nlRead(__message, serialCont, data);
706 multiPartMsgBody(sender, charId, partId, data);
707 }
708
709 void CShareServerEditionItfSkel::multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
710 {
711 H_AUTO(CShareServerEditionItfSkel_multiPartMsgFoot_DSS_FOOT);
712 uint32 charId;
713 nlRead(__message, serial, charId);
714 multiPartMsgFoot(sender, charId);
715 }
716
717 void CShareServerEditionItfSkel::forwardToDss_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
718 {
719 H_AUTO(CShareServerEditionItfSkel_forwardToDss_DSS_FW);
720 uint32 charId;
721 nlRead(__message, serial, charId);
722 NLNET::CMessage msg;
723 nlRead(__message, serialMessage, msg);
724 forwardToDss(sender, charId, msg);
725 }
726 void CShareServerEditionItfProxy::startingScenario(NLNET::IModule *sender)
727 {
728 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
729 {
730 // immediate local synchronous dispatching
731 _LocalModuleSkel->startingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
732 }
733 else
734 {
735 // send the message for remote dispatching and execution or local queing
736 NLNET::CMessage __message;
737
738 buildMessageFor_startingScenario(__message);
739
740 _ModuleProxy->sendModuleMessage(sender, __message);
741 }
742 }
743 // Request the start of a test scenario
744 void CShareServerEditionItfProxy::startScenario(NLNET::IModule *sender, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct)
745 {
746 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
747 {
748 // immediate local synchronous dispatching
749 _LocalModuleSkel->startScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, header, data, startingAct);
750 }
751 else
752 {
753 // send the message for remote dispatching and execution or local queing
754 NLNET::CMessage __message;
755
756 buildMessageFor_startScenario(__message, ok, header, data, startingAct);
757
758 _ModuleProxy->sendModuleMessage(sender, __message);
759 }
760 }
761 // Client has received the ADV_CONN message
762 void CShareServerEditionItfProxy::advConnACK(NLNET::IModule *sender)
763 {
764 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
765 {
766 // immediate local synchronous dispatching
767 _LocalModuleSkel->advConnACK(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
768 }
769 else
770 {
771 // send the message for remote dispatching and execution or local queing
772 NLNET::CMessage __message;
773
774 buildMessageFor_advConnACK(__message);
775
776 _ModuleProxy->sendModuleMessage(sender, __message);
777 }
778 }
779 // The client announce to the server that he has registered a component.
780 void CShareServerEditionItfProxy::onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5)
781 {
782 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
783 {
784 // immediate local synchronous dispatching
785 _LocalModuleSkel->onUserComponentRegistered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5);
786 }
787 else
788 {
789 // send the message for remote dispatching and execution or local queing
790 NLNET::CMessage __message;
791
792 buildMessageFor_onUserComponentRegistered(__message, md5);
793
794 _ModuleProxy->sendModuleMessage(sender, __message);
795 }
796 }
797 // The client announce to the server that he need a componennt so the server must uploading it.
798 void CShareServerEditionItfProxy::onUserComponentDownloading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5)
799 {
800 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
801 {
802 // immediate local synchronous dispatching
803 _LocalModuleSkel->onUserComponentDownloading(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5);
804 }
805 else
806 {
807 // send the message for remote dispatching and execution or local queing
808 NLNET::CMessage __message;
809
810 buildMessageFor_onUserComponentDownloading(__message, md5);
811
812 _ModuleProxy->sendModuleMessage(sender, __message);
813 }
814 }
815 // Upload the high level scenario.
816 void CShareServerEditionItfProxy::onScenarioUploadAsked(NLNET::IModule *sender, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast)
817 {
818 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
819 {
820 // immediate local synchronous dispatching
821 _LocalModuleSkel->onScenarioUploadAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, hlScenario, mustBrodcast);
822 }
823 else
824 {
825 // send the message for remote dispatching and execution or local queing
826 NLNET::CMessage __message;
827
828 buildMessageFor_onScenarioUploadAsked(__message, msgId, hlScenario, mustBrodcast);
829
830 _ModuleProxy->sendModuleMessage(sender, __message);
831 }
832 }
833 // The client request to set a node on a hl scenario.
834 void CShareServerEditionItfProxy::onNodeSetAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value)
835 {
836 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
837 {
838 // immediate local synchronous dispatching
839 _LocalModuleSkel->onNodeSetAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, value);
840 }
841 else
842 {
843 // send the message for remote dispatching and execution or local queing
844 NLNET::CMessage __message;
845
846 buildMessageFor_onNodeSetAsked(__message, msgId, instanceId, attrName, value);
847
848 _ModuleProxy->sendModuleMessage(sender, __message);
849 }
850 }
851 // The client request to insert a node on a hl scenario.
852 void CShareServerEditionItfProxy::onNodeInsertAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value)
853 {
854 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
855 {
856 // immediate local synchronous dispatching
857 _LocalModuleSkel->onNodeInsertAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, position, key, value);
858 }
859 else
860 {
861 // send the message for remote dispatching and execution or local queing
862 NLNET::CMessage __message;
863
864 buildMessageFor_onNodeInsertAsked(__message, msgId, instanceId, attrName, position, key, value);
865
866 _ModuleProxy->sendModuleMessage(sender, __message);
867 }
868 }
869 // The client request to erase a node on a hl scenario.
870 void CShareServerEditionItfProxy::onNodeEraseAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position)
871 {
872 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
873 {
874 // immediate local synchronous dispatching
875 _LocalModuleSkel->onNodeEraseAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, position);
876 }
877 else
878 {
879 // send the message for remote dispatching and execution or local queing
880 NLNET::CMessage __message;
881
882 buildMessageFor_onNodeEraseAsked(__message, msgId, instanceId, attrName, position);
883
884 _ModuleProxy->sendModuleMessage(sender, __message);
885 }
886 }
887 // The client request to move a node on a hl scenario.
888 void CShareServerEditionItfProxy::onNodeMoveAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2)
889 {
890 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
891 {
892 // immediate local synchronous dispatching
893 _LocalModuleSkel->onNodeMoveAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2);
894 }
895 else
896 {
897 // send the message for remote dispatching and execution or local queing
898 NLNET::CMessage __message;
899
900 buildMessageFor_onNodeMoveAsked(__message, msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2);
901
902 _ModuleProxy->sendModuleMessage(sender, __message);
903 }
904 }
905 // Call by the client in order to download its current scenario (and tp).
906 void CShareServerEditionItfProxy::onMapConnectionAsked(NLNET::IModule *sender, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role)
907 {
908 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
909 {
910 // immediate local synchronous dispatching
911 _LocalModuleSkel->onMapConnectionAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), scenarioId, updateHighLevel, mustTp, role);
912 }
913 else
914 {
915 // send the message for remote dispatching and execution or local queing
916 NLNET::CMessage __message;
917
918 buildMessageFor_onMapConnectionAsked(__message, scenarioId, updateHighLevel, mustTp, role);
919
920 _ModuleProxy->sendModuleMessage(sender, __message);
921 }
922 }
923 // Call by the client when he change its mode (Dm, Tester, Player)
924 void CShareServerEditionItfProxy::onCharModeUpdateAsked(NLNET::IModule *sender, R2::TCharMode mode)
925 {
926 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
927 {
928 // immediate local synchronous dispatching
929 _LocalModuleSkel->onCharModeUpdateAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), mode);
930 }
931 else
932 {
933 // send the message for remote dispatching and execution or local queing
934 NLNET::CMessage __message;
935
936 buildMessageFor_onCharModeUpdateAsked(__message, mode);
937
938 _ModuleProxy->sendModuleMessage(sender, __message);
939 }
940 }
941 // client wants to tp at a specific position (clicking in map)
942 void CShareServerEditionItfProxy::onTpPositionAsked(NLNET::IModule *sender, float x, float y, float z)
943 {
944 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
945 {
946 // immediate local synchronous dispatching
947 _LocalModuleSkel->onTpPositionAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), x, y, z);
948 }
949 else
950 {
951 // send the message for remote dispatching and execution or local queing
952 NLNET::CMessage __message;
953
954 buildMessageFor_onTpPositionAsked(__message, x, y, z);
955
956 _ModuleProxy->sendModuleMessage(sender, __message);
957 }
958 }
959 // Update the mode of the pioneer (DM/TEST).
960 void CShareServerEditionItfProxy::tpToEntryPoint(NLNET::IModule *sender, uint32 actIndex)
961 {
962 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
963 {
964 // immediate local synchronous dispatching
965 _LocalModuleSkel->tpToEntryPoint(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex);
966 }
967 else
968 {
969 // send the message for remote dispatching and execution or local queing
970 NLNET::CMessage __message;
971
972 buildMessageFor_tpToEntryPoint(__message, actIndex);
973
974 _ModuleProxy->sendModuleMessage(sender, __message);
975 }
976 }
977 // Set the starting act of the scenario
978 void CShareServerEditionItfProxy::setStartingAct(NLNET::IModule *sender, uint32 actIndex)
979 {
980 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
981 {
982 // immediate local synchronous dispatching
983 _LocalModuleSkel->setStartingAct(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex);
984 }
985 else
986 {
987 // send the message for remote dispatching and execution or local queing
988 NLNET::CMessage __message;
989
990 buildMessageFor_setStartingAct(__message, actIndex);
991
992 _ModuleProxy->sendModuleMessage(sender, __message);
993 }
994 }
995 // Update the ring access of a scenario.
996 void CShareServerEditionItfProxy::onScenarioRingAccessUpdated(NLNET::IModule *sender, bool ok, const std::string &ringAccess, const std::string &errMsg)
997 {
998 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
999 {
1000 // immediate local synchronous dispatching
1001 _LocalModuleSkel->onScenarioRingAccessUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, ringAccess, errMsg);
1002 }
1003 else
1004 {
1005 // send the message for remote dispatching and execution or local queing
1006 NLNET::CMessage __message;
1007
1008 buildMessageFor_onScenarioRingAccessUpdated(__message, ok, ringAccess, errMsg);
1009
1010 _ModuleProxy->sendModuleMessage(sender, __message);
1011 }
1012 }
1013 // a message to validate a file waiting to be saved
1014 void CShareServerEditionItfProxy::saveScenarioFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header)
1015 {
1016 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1017 {
1018 // immediate local synchronous dispatching
1019 _LocalModuleSkel->saveScenarioFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, header);
1020 }
1021 else
1022 {
1023 // send the message for remote dispatching and execution or local queing
1024 NLNET::CMessage __message;
1025
1026 buildMessageFor_saveScenarioFile(__message, md5, header);
1027
1028 _ModuleProxy->sendModuleMessage(sender, __message);
1029 }
1030 }
1031 // a message to validate a file waiting to be loaded
1032 void CShareServerEditionItfProxy::loadScenarioFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature)
1033 {
1034 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1035 {
1036 // immediate local synchronous dispatching
1037 _LocalModuleSkel->loadScenarioFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature);
1038 }
1039 else
1040 {
1041 // send the message for remote dispatching and execution or local queing
1042 NLNET::CMessage __message;
1043
1044 buildMessageFor_loadScenarioFile(__message, md5, signature);
1045
1046 _ModuleProxy->sendModuleMessage(sender, __message);
1047 }
1048 }
1049 // a message to validate a user component file waiting to be saved
1050 void CShareServerEditionItfProxy::saveUserComponentFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header)
1051 {
1052 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1053 {
1054 // immediate local synchronous dispatching
1055 _LocalModuleSkel->saveUserComponentFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, header);
1056 }
1057 else
1058 {
1059 // send the message for remote dispatching and execution or local queing
1060 NLNET::CMessage __message;
1061
1062 buildMessageFor_saveUserComponentFile(__message, md5, header);
1063
1064 _ModuleProxy->sendModuleMessage(sender, __message);
1065 }
1066 }
1067 // a message to validate a user component file waiting to be loaded
1068 void CShareServerEditionItfProxy::loadUserComponentFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature)
1069 {
1070 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1071 {
1072 // immediate local synchronous dispatching
1073 _LocalModuleSkel->loadUserComponentFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature);
1074 }
1075 else
1076 {
1077 // send the message for remote dispatching and execution or local queing
1078 NLNET::CMessage __message;
1079
1080 buildMessageFor_loadUserComponentFile(__message, md5, signature);
1081
1082 _ModuleProxy->sendModuleMessage(sender, __message);
1083 }
1084 }
1085 // a message to ask the dss to teleport a character to another character
1086 void CShareServerEditionItfProxy::teleportOneCharacterToAnother(NLNET::IModule *sender, TSessionId sessionId, uint32 sourceId, uint32 destId)
1087 {
1088 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1089 {
1090 // immediate local synchronous dispatching
1091 _LocalModuleSkel->teleportOneCharacterToAnother(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, sourceId, destId);
1092 }
1093 else
1094 {
1095 // send the message for remote dispatching and execution or local queing
1096 NLNET::CMessage __message;
1097
1098 buildMessageFor_teleportOneCharacterToAnother(__message, sessionId, sourceId, destId);
1099
1100 _ModuleProxy->sendModuleMessage(sender, __message);
1101 }
1102 }
1103 // teleport the player while uploading the scenario
1104 void CShareServerEditionItfProxy::teleportWhileUploadingScenario(NLNET::IModule *sender, const std::string &island, const std::string &entryPoint, const std::string &season)
1105 {
1106 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1107 {
1108 // immediate local synchronous dispatching
1109 _LocalModuleSkel->teleportWhileUploadingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), island, entryPoint, season);
1110 }
1111 else
1112 {
1113 // send the message for remote dispatching and execution or local queing
1114 NLNET::CMessage __message;
1115
1116 buildMessageFor_teleportWhileUploadingScenario(__message, island, entryPoint, season);
1117
1118 _ModuleProxy->sendModuleMessage(sender, __message);
1119 }
1120 }
1121 // send the header of a multi-part message
1122 void CShareServerEditionItfProxy::multiPartMsgHead(NLNET::IModule *sender, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size)
1123 {
1124 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1125 {
1126 // immediate local synchronous dispatching
1127 _LocalModuleSkel->multiPartMsgHead(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, msgName, nbPacket, size);
1128 }
1129 else
1130 {
1131 // send the message for remote dispatching and execution or local queing
1132 NLNET::CMessage __message;
1133
1134 buildMessageFor_multiPartMsgHead(__message, charId, msgName, nbPacket, size);
1135
1136 _ModuleProxy->sendModuleMessage(sender, __message);
1137 }
1138 }
1139 // send a part of a multi-part message
1140 void CShareServerEditionItfProxy::multiPartMsgBody(NLNET::IModule *sender, uint32 charId, uint32 partId, const std::vector<uint8> &data)
1141 {
1142 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1143 {
1144 // immediate local synchronous dispatching
1145 _LocalModuleSkel->multiPartMsgBody(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, partId, data);
1146 }
1147 else
1148 {
1149 // send the message for remote dispatching and execution or local queing
1150 NLNET::CMessage __message;
1151
1152 buildMessageFor_multiPartMsgBody(__message, charId, partId, data);
1153
1154 _ModuleProxy->sendModuleMessage(sender, __message);
1155 }
1156 }
1157 // send the footer of a multi-part message
1158 void CShareServerEditionItfProxy::multiPartMsgFoot(NLNET::IModule *sender, uint32 charId)
1159 {
1160 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1161 {
1162 // immediate local synchronous dispatching
1163 _LocalModuleSkel->multiPartMsgFoot(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId);
1164 }
1165 else
1166 {
1167 // send the message for remote dispatching and execution or local queing
1168 NLNET::CMessage __message;
1169
1170 buildMessageFor_multiPartMsgFoot(__message, charId);
1171
1172 _ModuleProxy->sendModuleMessage(sender, __message);
1173 }
1174 }
1175 // simulate the forward of a message (to dss)
1176 void CShareServerEditionItfProxy::forwardToDss(NLNET::IModule *sender, uint32 charId, const NLNET::CMessage &msg)
1177 {
1178 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1179 {
1180 // immediate local synchronous dispatching
1181 _LocalModuleSkel->forwardToDss(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, msg);
1182 }
1183 else
1184 {
1185 // send the message for remote dispatching and execution or local queing
1186 NLNET::CMessage __message;
1187
1188 buildMessageFor_forwardToDss(__message, charId, msg);
1189
1190 _ModuleProxy->sendModuleMessage(sender, __message);
1191 }
1192 }
1193
1194 // Message serializer. Return the message received in reference for easier integration
1195 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_startingScenario(NLNET::CMessage &__message)
1196 {
1197 __message.setType("RSS1");
1198
1199
1200 return __message;
1201 }
1202
1203 // Message serializer. Return the message received in reference for easier integration
1204 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct)
1205 {
1206 __message.setType("RSS2");
1207 nlWrite(__message, serial, ok);
1208 nlWrite(__message, serial, const_cast < TScenarioHeaderSerializer& > (header));
1209 nlWrite(__message, serial, const_cast < CObjectSerializerServer& > (data));
1210 nlWrite(__message, serial, startingAct);
1211
1212
1213 return __message;
1214 }
1215
1216 // Message serializer. Return the message received in reference for easier integration
1217 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_advConnACK(NLNET::CMessage &__message)
1218 {
1219 __message.setType("ADC_ACK");
1220
1221
1222 return __message;
1223 }
1224
1225 // Message serializer. Return the message received in reference for easier integration
1226 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5)
1227 {
1228 __message.setType("SUCR");
1229 nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5));
1230
1231
1232 return __message;
1233 }
1234
1235 // Message serializer. Return the message received in reference for easier integration
1236 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onUserComponentDownloading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5)
1237 {
1238 __message.setType("SUCD");
1239 nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5));
1240
1241
1242 return __message;
1243 }
1244
1245 // Message serializer. Return the message received in reference for easier integration
1246 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onScenarioUploadAsked(NLNET::CMessage &__message, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast)
1247 {
1248 __message.setType("SSUA");
1249 nlWrite(__message, serial, msgId);
1250 nlWrite(__message, serial, const_cast < CObjectSerializerServer& > (hlScenario));
1251 nlWrite(__message, serial, mustBrodcast);
1252
1253
1254 return __message;
1255 }
1256
1257 // Message serializer. Return the message received in reference for easier integration
1258 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeSetAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value)
1259 {
1260 __message.setType("SNSA");
1261 nlWrite(__message, serial, msgId);
1262 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
1263 nlWrite(__message, serial, const_cast < std::string& > (attrName));
1264 nlWrite(__message, serial, const_cast < R2::CObjectSerializerServer& > (value));
1265
1266
1267 return __message;
1268 }
1269
1270 // Message serializer. Return the message received in reference for easier integration
1271 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeInsertAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value)
1272 {
1273 __message.setType("SNIA");
1274 nlWrite(__message, serial, msgId);
1275 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
1276 nlWrite(__message, serial, const_cast < std::string& > (attrName));
1277 nlWrite(__message, serial, position);
1278 nlWrite(__message, serial, const_cast < std::string& > (key));
1279 nlWrite(__message, serial, const_cast < R2::CObjectSerializerServer& > (value));
1280
1281
1282 return __message;
1283 }
1284
1285 // Message serializer. Return the message received in reference for easier integration
1286 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeEraseAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position)
1287 {
1288 __message.setType("SNEA");
1289 nlWrite(__message, serial, msgId);
1290 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
1291 nlWrite(__message, serial, const_cast < std::string& > (attrName));
1292 nlWrite(__message, serial, position);
1293
1294
1295 return __message;
1296 }
1297
1298 // Message serializer. Return the message received in reference for easier integration
1299 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeMoveAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2)
1300 {
1301 __message.setType("SNMA");
1302 nlWrite(__message, serial, msgId);
1303 nlWrite(__message, serial, const_cast < std::string& > (instanceId1));
1304 nlWrite(__message, serial, const_cast < std::string& > (attrName1));
1305 nlWrite(__message, serial, position1);
1306 nlWrite(__message, serial, const_cast < std::string& > (instanceId2));
1307 nlWrite(__message, serial, const_cast < std::string& > (attrName2));
1308 nlWrite(__message, serial, position2);
1309
1310
1311 return __message;
1312 }
1313
1314 // Message serializer. Return the message received in reference for easier integration
1315 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onMapConnectionAsked(NLNET::CMessage &__message, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role)
1316 {
1317 __message.setType("SMCA");
1318 nlWrite(__message, serial, scenarioId);
1319 nlWrite(__message, serial, updateHighLevel);
1320 nlWrite(__message, serial, mustTp);
1321 nlWrite(__message, serial, role);
1322
1323
1324 return __message;
1325 }
1326
1327 // Message serializer. Return the message received in reference for easier integration
1328 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onCharModeUpdateAsked(NLNET::CMessage &__message, R2::TCharMode mode)
1329 {
1330 __message.setType("SCMUA");
1331 nlWrite(__message, serial, mode);
1332
1333
1334 return __message;
1335 }
1336
1337 // Message serializer. Return the message received in reference for easier integration
1338 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onTpPositionAsked(NLNET::CMessage &__message, float x, float y, float z)
1339 {
1340 __message.setType("STPA");
1341 nlWrite(__message, serial, x);
1342 nlWrite(__message, serial, y);
1343 nlWrite(__message, serial, z);
1344
1345
1346 return __message;
1347 }
1348
1349 // Message serializer. Return the message received in reference for easier integration
1350 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_tpToEntryPoint(NLNET::CMessage &__message, uint32 actIndex)
1351 {
1352 __message.setType("TPEP");
1353 nlWrite(__message, serial, actIndex);
1354
1355
1356 return __message;
1357 }
1358
1359 // Message serializer. Return the message received in reference for easier integration
1360 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_setStartingAct(NLNET::CMessage &__message, uint32 actIndex)
1361 {
1362 __message.setType("STA");
1363 nlWrite(__message, serial, actIndex);
1364
1365
1366 return __message;
1367 }
1368
1369 // Message serializer. Return the message received in reference for easier integration
1370 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onScenarioRingAccessUpdated(NLNET::CMessage &__message, bool ok, const std::string &ringAccess, const std::string &errMsg)
1371 {
1372 __message.setType("SRAU");
1373 nlWrite(__message, serial, ok);
1374 nlWrite(__message, serial, const_cast < std::string& > (ringAccess));
1375 nlWrite(__message, serial, const_cast < std::string& > (errMsg));
1376
1377
1378 return __message;
1379 }
1380
1381 // Message serializer. Return the message received in reference for easier integration
1382 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_saveScenarioFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header)
1383 {
1384 __message.setType("SSSFA");
1385 nlWrite(__message, serial, const_cast < std::string& > (md5));
1386 nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (header));
1387
1388
1389 return __message;
1390 }
1391
1392 // Message serializer. Return the message received in reference for easier integration
1393 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_loadScenarioFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature)
1394 {
1395 __message.setType("SLSFA");
1396 nlWrite(__message, serial, const_cast < std::string& > (md5));
1397 nlWrite(__message, serial, const_cast < std::string& > (signature));
1398
1399
1400 return __message;
1401 }
1402
1403 // Message serializer. Return the message received in reference for easier integration
1404 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_saveUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header)
1405 {
1406 __message.setType("SUCF");
1407 nlWrite(__message, serial, const_cast < std::string& > (md5));
1408 nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (header));
1409
1410
1411 return __message;
1412 }
1413
1414 // Message serializer. Return the message received in reference for easier integration
1415 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_loadUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature)
1416 {
1417 __message.setType("LUCF");
1418 nlWrite(__message, serial, const_cast < std::string& > (md5));
1419 nlWrite(__message, serial, const_cast < std::string& > (signature));
1420
1421
1422 return __message;
1423 }
1424
1425 // Message serializer. Return the message received in reference for easier integration
1426 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_teleportOneCharacterToAnother(NLNET::CMessage &__message, TSessionId sessionId, uint32 sourceId, uint32 destId)
1427 {
1428 __message.setType("STOCTA");
1429 nlWrite(__message, serial, sessionId);
1430 nlWrite(__message, serial, sourceId);
1431 nlWrite(__message, serial, destId);
1432
1433
1434 return __message;
1435 }
1436
1437 // Message serializer. Return the message received in reference for easier integration
1438 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_teleportWhileUploadingScenario(NLNET::CMessage &__message, const std::string &island, const std::string &entryPoint, const std::string &season)
1439 {
1440 __message.setType("STWUS");
1441 nlWrite(__message, serial, const_cast < std::string& > (island));
1442 nlWrite(__message, serial, const_cast < std::string& > (entryPoint));
1443 nlWrite(__message, serial, const_cast < std::string& > (season));
1444
1445
1446 return __message;
1447 }
1448
1449 // Message serializer. Return the message received in reference for easier integration
1450 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size)
1451 {
1452 __message.setType("DSS_HEAD");
1453 nlWrite(__message, serial, charId);
1454 nlWrite(__message, serial, const_cast < std::string& > (msgName));
1455 nlWrite(__message, serial, nbPacket);
1456 nlWrite(__message, serial, size);
1457
1458
1459 return __message;
1460 }
1461
1462 // Message serializer. Return the message received in reference for easier integration
1463 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 charId, uint32 partId, const std::vector<uint8> &data)
1464 {
1465 __message.setType("DSS_MSG");
1466 nlWrite(__message, serial, charId);
1467 nlWrite(__message, serial, partId);
1468 nlWrite(__message, serialCont, const_cast < std::vector<uint8>& > (data));
1469
1470
1471 return __message;
1472 }
1473
1474 // Message serializer. Return the message received in reference for easier integration
1475 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message, uint32 charId)
1476 {
1477 __message.setType("DSS_FOOT");
1478 nlWrite(__message, serial, charId);
1479
1480
1481 return __message;
1482 }
1483
1484 // Message serializer. Return the message received in reference for easier integration
1485 const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_forwardToDss(NLNET::CMessage &__message, uint32 charId, const NLNET::CMessage &msg)
1486 {
1487 __message.setType("DSS_FW");
1488 nlWrite(__message, serial, charId);
1489 nlWrite(__message, serialMessage, const_cast < NLNET::CMessage& > (msg));
1490
1491
1492 return __message;
1493 }
1494
1495 /////////////////////////////////////////////////////////////////
1496 // WARNING : this is a generated file, don't change it !
1497 /////////////////////////////////////////////////////////////////
1498
1499
1500 const CShareClientEditionItfSkel::TMessageHandlerMap &CShareClientEditionItfSkel::getMessageHandlers() const
1501 {
1502 static TMessageHandlerMap handlers;
1503 static bool init = false;
1504
1505 if (!init)
1506 {
1507 std::pair < TMessageHandlerMap::iterator, bool > res;
1508
1509 res = handlers.insert(std::make_pair(std::string("RSS1"), &CShareClientEditionItfSkel::startingScenario_skel));
1510 // if this assert, you have a doubly message name in your interface definition !
1511 nlassert(res.second);
1512
1513 res = handlers.insert(std::make_pair(std::string("RSS2"), &CShareClientEditionItfSkel::startScenario_skel));
1514 // if this assert, you have a doubly message name in your interface definition !
1515 nlassert(res.second);
1516
1517 res = handlers.insert(std::make_pair(std::string("CUCR"), &CShareClientEditionItfSkel::onUserComponentRegistered_skel));
1518 // if this assert, you have a doubly message name in your interface definition !
1519 nlassert(res.second);
1520
1521 res = handlers.insert(std::make_pair(std::string("CUCU"), &CShareClientEditionItfSkel::onUserComponentUploading_skel));
1522 // if this assert, you have a doubly message name in your interface definition !
1523 nlassert(res.second);
1524
1525 res = handlers.insert(std::make_pair(std::string("CSUA"), &CShareClientEditionItfSkel::onScenarioUploaded_skel));
1526 // if this assert, you have a doubly message name in your interface definition !
1527 nlassert(res.second);
1528
1529 res = handlers.insert(std::make_pair(std::string("CNSA"), &CShareClientEditionItfSkel::onNodeSet_skel));
1530 // if this assert, you have a doubly message name in your interface definition !
1531 nlassert(res.second);
1532
1533 res = handlers.insert(std::make_pair(std::string("CNIA"), &CShareClientEditionItfSkel::onNodeInserted_skel));
1534 // if this assert, you have a doubly message name in your interface definition !
1535 nlassert(res.second);
1536
1537 res = handlers.insert(std::make_pair(std::string("CNEA"), &CShareClientEditionItfSkel::onNodeErased_skel));
1538 // if this assert, you have a doubly message name in your interface definition !
1539 nlassert(res.second);
1540
1541 res = handlers.insert(std::make_pair(std::string("CNMA"), &CShareClientEditionItfSkel::onNodeMoved_skel));
1542 // if this assert, you have a doubly message name in your interface definition !
1543 nlassert(res.second);
1544
1545 res = handlers.insert(std::make_pair(std::string("CQU"), &CShareClientEditionItfSkel::onQuotaUpdated_skel));
1546 // if this assert, you have a doubly message name in your interface definition !
1547 nlassert(res.second);
1548
1549 res = handlers.insert(std::make_pair(std::string("CCMU"), &CShareClientEditionItfSkel::onCharModeUpdated_skel));
1550 // if this assert, you have a doubly message name in your interface definition !
1551 nlassert(res.second);
1552
1553 res = handlers.insert(std::make_pair(std::string("CTMD"), &CShareClientEditionItfSkel::onTestModeDisconnected_skel));
1554 // if this assert, you have a doubly message name in your interface definition !
1555 nlassert(res.second);
1556
1557 res = handlers.insert(std::make_pair(std::string("CTPPS"), &CShareClientEditionItfSkel::onTpPositionSimulated_skel));
1558 // if this assert, you have a doubly message name in your interface definition !
1559 nlassert(res.second);
1560
1561 res = handlers.insert(std::make_pair(std::string("COK"), &CShareClientEditionItfSkel::onKicked_skel));
1562 // if this assert, you have a doubly message name in your interface definition !
1563 nlassert(res.second);
1564
1565 res = handlers.insert(std::make_pair(std::string("COD"), &CShareClientEditionItfSkel::onDisconnected_skel));
1566 // if this assert, you have a doubly message name in your interface definition !
1567 nlassert(res.second);
1568
1569 res = handlers.insert(std::make_pair(std::string("SSA1"), &CShareClientEditionItfSkel::scheduleStartAct_skel));
1570 // if this assert, you have a doubly message name in your interface definition !
1571 nlassert(res.second);
1572
1573 res = handlers.insert(std::make_pair(std::string("OAMC"), &CShareClientEditionItfSkel::onAnimationModePlayConnected_skel));
1574 // if this assert, you have a doubly message name in your interface definition !
1575 nlassert(res.second);
1576
1577 res = handlers.insert(std::make_pair(std::string("CUSH"), &CShareClientEditionItfSkel::updateScenarioHeader_skel));
1578 // if this assert, you have a doubly message name in your interface definition !
1579 nlassert(res.second);
1580
1581 res = handlers.insert(std::make_pair(std::string("CUIT"), &CShareClientEditionItfSkel::updateMissionItemsDescription_skel));
1582 // if this assert, you have a doubly message name in your interface definition !
1583 nlassert(res.second);
1584
1585 res = handlers.insert(std::make_pair(std::string("CUAPD"), &CShareClientEditionItfSkel::updateActPositionDescriptions_skel));
1586 // if this assert, you have a doubly message name in your interface definition !
1587 nlassert(res.second);
1588
1589 res = handlers.insert(std::make_pair(std::string("CUUTD"), &CShareClientEditionItfSkel::updateUserTriggerDescriptions_skel));
1590 // if this assert, you have a doubly message name in your interface definition !
1591 nlassert(res.second);
1592
1593 res = handlers.insert(std::make_pair(std::string("CUAIU"), &CShareClientEditionItfSkel::onCurrentActIndexUpdated_skel));
1594 // if this assert, you have a doubly message name in your interface definition !
1595 nlassert(res.second);
1596
1597 res = handlers.insert(std::make_pair(std::string("CUTAL"), &CShareClientEditionItfSkel::updateTalkingAsList_skel));
1598 // if this assert, you have a doubly message name in your interface definition !
1599 nlassert(res.second);
1600
1601 res = handlers.insert(std::make_pair(std::string("CUIL"), &CShareClientEditionItfSkel::updateIncarningList_skel));
1602 // if this assert, you have a doubly message name in your interface definition !
1603 nlassert(res.second);
1604
1605 res = handlers.insert(std::make_pair(std::string("CSM"), &CShareClientEditionItfSkel::systemMsg_skel));
1606 // if this assert, you have a doubly message name in your interface definition !
1607 nlassert(res.second);
1608
1609 res = handlers.insert(std::make_pair(std::string("CRAU"), &CShareClientEditionItfSkel::onRingAccessUpdated_skel));
1610 // if this assert, you have a doubly message name in your interface definition !
1611 nlassert(res.second);
1612
1613 res = handlers.insert(std::make_pair(std::string("CSSFA"), &CShareClientEditionItfSkel::saveScenarioFileAccepted_skel));
1614 // if this assert, you have a doubly message name in your interface definition !
1615 nlassert(res.second);
1616
1617 res = handlers.insert(std::make_pair(std::string("CLSFA"), &CShareClientEditionItfSkel::loadScenarioFileAccepted_skel));
1618 // if this assert, you have a doubly message name in your interface definition !
1619 nlassert(res.second);
1620
1621 res = handlers.insert(std::make_pair(std::string("SUCFA"), &CShareClientEditionItfSkel::saveUserComponentFileAccepted_skel));
1622 // if this assert, you have a doubly message name in your interface definition !
1623 nlassert(res.second);
1624
1625 res = handlers.insert(std::make_pair(std::string("LUCFA"), &CShareClientEditionItfSkel::loadUserComponentFileAccepted_skel));
1626 // if this assert, you have a doubly message name in your interface definition !
1627 nlassert(res.second);
1628
1629 res = handlers.insert(std::make_pair(std::string("DSS_HEAD"), &CShareClientEditionItfSkel::multiPartMsgHead_skel));
1630 // if this assert, you have a doubly message name in your interface definition !
1631 nlassert(res.second);
1632
1633 res = handlers.insert(std::make_pair(std::string("DSS_MSG"), &CShareClientEditionItfSkel::multiPartMsgBody_skel));
1634 // if this assert, you have a doubly message name in your interface definition !
1635 nlassert(res.second);
1636
1637 res = handlers.insert(std::make_pair(std::string("DSS_FOOT"), &CShareClientEditionItfSkel::multiPartMsgFoot_skel));
1638 // if this assert, you have a doubly message name in your interface definition !
1639 nlassert(res.second);
1640
1641 res = handlers.insert(std::make_pair(std::string("CACKMSG"), &CShareClientEditionItfSkel::ackMsg_skel));
1642 // if this assert, you have a doubly message name in your interface definition !
1643 nlassert(res.second);
1644
1645 init = true;
1646 }
1647
1648 return handlers;
1649 }
1650 bool CShareClientEditionItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
1651 {
1652 const TMessageHandlerMap &mh = getMessageHandlers();
1653
1654 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
1655
1656 if (it == mh.end())
1657 {
1658 return false;
1659 }
1660
1661 TMessageHandler cmd = it->second;
1662 (this->*cmd)(sender, message);
1663
1664 return true;
1665 }
1666
1667
1668 void CShareClientEditionItfSkel::startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1669 {
1670 H_AUTO(CShareClientEditionItfSkel_startingScenario_RSS1);
1671 uint32 charId;
1672 nlRead(__message, serial, charId);
1673 startingScenario(sender, charId);
1674 }
1675
1676 void CShareClientEditionItfSkel::startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1677 {
1678 H_AUTO(CShareClientEditionItfSkel_startScenario_RSS2);
1679 bool ok;
1680 nlRead(__message, serial, ok);
1681 uint32 startingAct;
1682 nlRead(__message, serial, startingAct);
1683 std::string errorMsg;
1684 nlRead(__message, serial, errorMsg);
1685 startScenario(sender, ok, startingAct, errorMsg);
1686 }
1687
1688 void CShareClientEditionItfSkel::onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1689 {
1690 H_AUTO(CShareClientEditionItfSkel_onUserComponentRegistered_CUCR);
1691 NLMISC::CHashKeyMD5 md5;
1692 nlRead(__message, serial, md5);
1693 onUserComponentRegistered(sender, md5);
1694 }
1695
1696 void CShareClientEditionItfSkel::onUserComponentUploading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1697 {
1698 H_AUTO(CShareClientEditionItfSkel_onUserComponentUploading_CUCU);
1699 NLMISC::CHashKeyMD5 md5;
1700 nlRead(__message, serial, md5);
1701 onUserComponentUploading(sender, md5);
1702 }
1703
1704 void CShareClientEditionItfSkel::onScenarioUploaded_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1705 {
1706 H_AUTO(CShareClientEditionItfSkel_onScenarioUploaded_CSUA);
1707 R2::CObjectSerializerClient hlScenario;
1708 nlRead(__message, serial, hlScenario);
1709 onScenarioUploaded(sender, hlScenario);
1710 }
1711
1712 void CShareClientEditionItfSkel::onNodeSet_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1713 {
1714 H_AUTO(CShareClientEditionItfSkel_onNodeSet_CNSA);
1715 std::string instanceId;
1716 nlRead(__message, serial, instanceId);
1717 std::string attrName;
1718 nlRead(__message, serial, attrName);
1719 R2::CObjectSerializerClient value;
1720 nlRead(__message, serial, value);
1721 onNodeSet(sender, instanceId, attrName, value);
1722 }
1723
1724 void CShareClientEditionItfSkel::onNodeInserted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1725 {
1726 H_AUTO(CShareClientEditionItfSkel_onNodeInserted_CNIA);
1727 std::string instanceId;
1728 nlRead(__message, serial, instanceId);
1729 std::string attrName;
1730 nlRead(__message, serial, attrName);
1731 sint32 position;
1732 nlRead(__message, serial, position);
1733 std::string key;
1734 nlRead(__message, serial, key);
1735 R2::CObjectSerializerClient value;
1736 nlRead(__message, serial, value);
1737 onNodeInserted(sender, instanceId, attrName, position, key, value);
1738 }
1739
1740 void CShareClientEditionItfSkel::onNodeErased_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1741 {
1742 H_AUTO(CShareClientEditionItfSkel_onNodeErased_CNEA);
1743 std::string instanceId;
1744 nlRead(__message, serial, instanceId);
1745 std::string attrName;
1746 nlRead(__message, serial, attrName);
1747 sint32 position;
1748 nlRead(__message, serial, position);
1749 onNodeErased(sender, instanceId, attrName, position);
1750 }
1751
1752 void CShareClientEditionItfSkel::onNodeMoved_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1753 {
1754 H_AUTO(CShareClientEditionItfSkel_onNodeMoved_CNMA);
1755 std::string instanceId1;
1756 nlRead(__message, serial, instanceId1);
1757 std::string attrName1;
1758 nlRead(__message, serial, attrName1);
1759 sint32 position1;
1760 nlRead(__message, serial, position1);
1761 std::string instanceId2;
1762 nlRead(__message, serial, instanceId2);
1763 std::string attrName2;
1764 nlRead(__message, serial, attrName2);
1765 sint32 position2;
1766 nlRead(__message, serial, position2);
1767 onNodeMoved(sender, instanceId1, attrName1, position1, instanceId2, attrName2, position2);
1768 }
1769
1770 void CShareClientEditionItfSkel::onQuotaUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1771 {
1772 H_AUTO(CShareClientEditionItfSkel_onQuotaUpdated_CQU);
1773 uint32 maxNpcs;
1774 nlRead(__message, serial, maxNpcs);
1775 uint32 maxStaticObjects;
1776 nlRead(__message, serial, maxStaticObjects);
1777 onQuotaUpdated(sender, maxNpcs, maxStaticObjects);
1778 }
1779
1780 void CShareClientEditionItfSkel::onCharModeUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1781 {
1782 H_AUTO(CShareClientEditionItfSkel_onCharModeUpdated_CCMU);
1783 R2::TCharMode mode;
1784 nlRead(__message, serial, mode);
1785 onCharModeUpdated(sender, mode);
1786 }
1787
1788 void CShareClientEditionItfSkel::onTestModeDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1789 {
1790 H_AUTO(CShareClientEditionItfSkel_onTestModeDisconnected_CTMD);
1791 TSessionId sessionId;
1792 nlRead(__message, serial, sessionId);
1793 uint32 lastActIndex;
1794 nlRead(__message, serial, lastActIndex);
1795 R2::TScenarioSessionType animationType;
1796 nlRead(__message, serialEnum, animationType);
1797 onTestModeDisconnected(sender, sessionId, lastActIndex, animationType);
1798 }
1799
1800 void CShareClientEditionItfSkel::onTpPositionSimulated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1801 {
1802 H_AUTO(CShareClientEditionItfSkel_onTpPositionSimulated_CTPPS);
1803 TSessionId sessionId;
1804 nlRead(__message, serial, sessionId);
1805 uint64 characterId64;
1806 nlRead(__message, serial, characterId64);
1807 sint32 x;
1808 nlRead(__message, serial, x);
1809 sint32 y;
1810 nlRead(__message, serial, y);
1811 sint32 z;
1812 nlRead(__message, serial, z);
1813 uint8 scenarioSeason;
1814 nlRead(__message, serial, scenarioSeason);
1815 onTpPositionSimulated(sender, sessionId, characterId64, x, y, z, scenarioSeason);
1816 }
1817
1818 void CShareClientEditionItfSkel::onKicked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1819 {
1820 H_AUTO(CShareClientEditionItfSkel_onKicked_COK);
1821 uint32 timeBeforeDisconnection;
1822 nlRead(__message, serial, timeBeforeDisconnection);
1823 bool mustKick;
1824 nlRead(__message, serial, mustKick);
1825 onKicked(sender, timeBeforeDisconnection, mustKick);
1826 }
1827
1828 void CShareClientEditionItfSkel::onDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
1829 {
1830 H_AUTO(CShareClientEditionItfSkel_onDisconnected_COD);
1831 onDisconnected(sender);
1832 }
1833
1834 void CShareClientEditionItfSkel::scheduleStartAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1835 {
1836 H_AUTO(CShareClientEditionItfSkel_scheduleStartAct_SSA1);
1837 uint32 errorId;
1838 nlRead(__message, serial, errorId);
1839 uint32 actId;
1840 nlRead(__message, serial, actId);
1841 uint32 nbSeconds;
1842 nlRead(__message, serial, nbSeconds);
1843 scheduleStartAct(sender, errorId, actId, nbSeconds);
1844 }
1845
1846 void CShareClientEditionItfSkel::onAnimationModePlayConnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
1847 {
1848 H_AUTO(CShareClientEditionItfSkel_onAnimationModePlayConnected_OAMC);
1849 onAnimationModePlayConnected(sender);
1850 }
1851
1852 void CShareClientEditionItfSkel::updateScenarioHeader_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1853 {
1854 H_AUTO(CShareClientEditionItfSkel_updateScenarioHeader_CUSH);
1855 R2::TScenarioHeaderSerializer scenarioHeader;
1856 nlRead(__message, serial, scenarioHeader);
1857 updateScenarioHeader(sender, scenarioHeader);
1858 }
1859
1860 void CShareClientEditionItfSkel::updateMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1861 {
1862 H_AUTO(CShareClientEditionItfSkel_updateMissionItemsDescription_CUIT);
1863 TSessionId sessionId;
1864 nlRead(__message, serial, sessionId);
1865 std::vector<R2::TMissionItem> missionItem;
1866 nlRead(__message, serialCont, missionItem);
1867 updateMissionItemsDescription(sender, sessionId, missionItem);
1868 }
1869
1870 void CShareClientEditionItfSkel::updateActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1871 {
1872 H_AUTO(CShareClientEditionItfSkel_updateActPositionDescriptions_CUAPD);
1873 R2::TActPositionDescriptions actPositionDescriptions;
1874 nlRead(__message, serialCont, actPositionDescriptions);
1875 updateActPositionDescriptions(sender, actPositionDescriptions);
1876 }
1877
1878 void CShareClientEditionItfSkel::updateUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1879 {
1880 H_AUTO(CShareClientEditionItfSkel_updateUserTriggerDescriptions_CUUTD);
1881 R2::TUserTriggerDescriptions userTriggerDescriptions;
1882 nlRead(__message, serialCont, userTriggerDescriptions);
1883 updateUserTriggerDescriptions(sender, userTriggerDescriptions);
1884 }
1885
1886 void CShareClientEditionItfSkel::onCurrentActIndexUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1887 {
1888 H_AUTO(CShareClientEditionItfSkel_onCurrentActIndexUpdated_CUAIU);
1889 uint32 actIndex;
1890 nlRead(__message, serial, actIndex);
1891 onCurrentActIndexUpdated(sender, actIndex);
1892 }
1893
1894 void CShareClientEditionItfSkel::updateTalkingAsList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1895 {
1896 H_AUTO(CShareClientEditionItfSkel_updateTalkingAsList_CUTAL);
1897 std::vector<uint32> botsId;
1898 nlRead(__message, serialCont, botsId);
1899 updateTalkingAsList(sender, botsId);
1900 }
1901
1902 void CShareClientEditionItfSkel::updateIncarningList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1903 {
1904 H_AUTO(CShareClientEditionItfSkel_updateIncarningList_CUIL);
1905 std::vector<uint32> botsId;
1906 nlRead(__message, serialCont, botsId);
1907 updateIncarningList(sender, botsId);
1908 }
1909
1910 void CShareClientEditionItfSkel::systemMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1911 {
1912 H_AUTO(CShareClientEditionItfSkel_systemMsg_CSM);
1913 std::string msgType;
1914 nlRead(__message, serial, msgType);
1915 std::string who;
1916 nlRead(__message, serial, who);
1917 std::string msg;
1918 nlRead(__message, serial, msg);
1919 systemMsg(sender, msgType, who, msg);
1920 }
1921
1922 void CShareClientEditionItfSkel::onRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1923 {
1924 H_AUTO(CShareClientEditionItfSkel_onRingAccessUpdated_CRAU);
1925 std::string ringAccess;
1926 nlRead(__message, serial, ringAccess);
1927 onRingAccessUpdated(sender, ringAccess);
1928 }
1929
1930 void CShareClientEditionItfSkel::saveScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1931 {
1932 H_AUTO(CShareClientEditionItfSkel_saveScenarioFileAccepted_CSSFA);
1933 std::string md5;
1934 nlRead(__message, serial, md5);
1935 std::string signature;
1936 nlRead(__message, serial, signature);
1937 bool isAccepted;
1938 nlRead(__message, serial, isAccepted);
1939 saveScenarioFileAccepted(sender, md5, signature, isAccepted);
1940 }
1941
1942 void CShareClientEditionItfSkel::loadScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1943 {
1944 H_AUTO(CShareClientEditionItfSkel_loadScenarioFileAccepted_CLSFA);
1945 std::string md5;
1946 nlRead(__message, serial, md5);
1947 bool ok;
1948 nlRead(__message, serial, ok);
1949 loadScenarioFileAccepted(sender, md5, ok);
1950 }
1951
1952 void CShareClientEditionItfSkel::saveUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1953 {
1954 H_AUTO(CShareClientEditionItfSkel_saveUserComponentFileAccepted_SUCFA);
1955 std::string md5;
1956 nlRead(__message, serial, md5);
1957 std::string signature;
1958 nlRead(__message, serial, signature);
1959 bool isAccepted;
1960 nlRead(__message, serial, isAccepted);
1961 saveUserComponentFileAccepted(sender, md5, signature, isAccepted);
1962 }
1963
1964 void CShareClientEditionItfSkel::loadUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1965 {
1966 H_AUTO(CShareClientEditionItfSkel_loadUserComponentFileAccepted_LUCFA);
1967 std::string md5;
1968 nlRead(__message, serial, md5);
1969 bool ok;
1970 nlRead(__message, serial, ok);
1971 loadUserComponentFileAccepted(sender, md5, ok);
1972 }
1973
1974 void CShareClientEditionItfSkel::multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1975 {
1976 H_AUTO(CShareClientEditionItfSkel_multiPartMsgHead_DSS_HEAD);
1977 std::string msgName;
1978 nlRead(__message, serial, msgName);
1979 uint32 nbPacket;
1980 nlRead(__message, serial, nbPacket);
1981 uint32 size;
1982 nlRead(__message, serial, size);
1983 multiPartMsgHead(sender, msgName, nbPacket, size);
1984 }
1985
1986 void CShareClientEditionItfSkel::multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1987 {
1988 H_AUTO(CShareClientEditionItfSkel_multiPartMsgBody_DSS_MSG);
1989 uint32 partId;
1990 nlRead(__message, serial, partId);
1991 uint32 packetSize;
1992 nlRead(__message, serial, packetSize);
1993 multiPartMsgBody(sender, partId, packetSize);
1994 }
1995
1996 void CShareClientEditionItfSkel::multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
1997 {
1998 H_AUTO(CShareClientEditionItfSkel_multiPartMsgFoot_DSS_FOOT);
1999 multiPartMsgFoot(sender);
2000 }
2001
2002 void CShareClientEditionItfSkel::ackMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
2003 {
2004 H_AUTO(CShareClientEditionItfSkel_ackMsg_CACKMSG);
2005 uint32 msgId;
2006 nlRead(__message, serial, msgId);
2007 bool ok;
2008 nlRead(__message, serial, ok);
2009 ackMsg(sender, msgId, ok);
2010 }
2011 // The start of a test has been requested
2012 void CShareClientEditionItfProxy::startingScenario(NLNET::IModule *sender, uint32 charId)
2013 {
2014 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2015 {
2016 // immediate local synchronous dispatching
2017 _LocalModuleSkel->startingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId);
2018 }
2019 else
2020 {
2021 // send the message for remote dispatching and execution or local queing
2022 NLNET::CMessage __message;
2023
2024 buildMessageFor_startingScenario(__message, charId);
2025
2026 _ModuleProxy->sendModuleMessage(sender, __message);
2027 }
2028 }
2029 // A Scenario has started
2030 void CShareClientEditionItfProxy::startScenario(NLNET::IModule *sender, bool ok, uint32 startingAct, const std::string &errorMsg)
2031 {
2032 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2033 {
2034 // immediate local synchronous dispatching
2035 _LocalModuleSkel->startScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, startingAct, errorMsg);
2036 }
2037 else
2038 {
2039 // send the message for remote dispatching and execution or local queing
2040 NLNET::CMessage __message;
2041
2042 buildMessageFor_startScenario(__message, ok, startingAct, errorMsg);
2043
2044 _ModuleProxy->sendModuleMessage(sender, __message);
2045 }
2046 }
2047 // A User component has been registered
2048 void CShareClientEditionItfProxy::onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5)
2049 {
2050 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2051 {
2052 // immediate local synchronous dispatching
2053 _LocalModuleSkel->onUserComponentRegistered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5);
2054 }
2055 else
2056 {
2057 // send the message for remote dispatching and execution or local queing
2058 NLNET::CMessage __message;
2059
2060 buildMessageFor_onUserComponentRegistered(__message, md5);
2061
2062 _ModuleProxy->sendModuleMessage(sender, __message);
2063 }
2064 }
2065 // Request the upload of a component
2066 void CShareClientEditionItfProxy::onUserComponentUploading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5)
2067 {
2068 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2069 {
2070 // immediate local synchronous dispatching
2071 _LocalModuleSkel->onUserComponentUploading(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5);
2072 }
2073 else
2074 {
2075 // send the message for remote dispatching and execution or local queing
2076 NLNET::CMessage __message;
2077
2078 buildMessageFor_onUserComponentUploading(__message, md5);
2079
2080 _ModuleProxy->sendModuleMessage(sender, __message);
2081 }
2082 }
2083 // The client request to upload an hl ata.
2084 void CShareClientEditionItfProxy::onScenarioUploaded(NLNET::IModule *sender, const R2::CObjectSerializerClient &hlScenario)
2085 {
2086 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2087 {
2088 // immediate local synchronous dispatching
2089 _LocalModuleSkel->onScenarioUploaded(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), hlScenario);
2090 }
2091 else
2092 {
2093 // send the message for remote dispatching and execution or local queing
2094 NLNET::CMessage __message;
2095
2096 buildMessageFor_onScenarioUploaded(__message, hlScenario);
2097
2098 _ModuleProxy->sendModuleMessage(sender, __message);
2099 }
2100 }
2101 // The client request to set a node on a hl scenario.
2102 void CShareClientEditionItfProxy::onNodeSet(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value)
2103 {
2104 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2105 {
2106 // immediate local synchronous dispatching
2107 _LocalModuleSkel->onNodeSet(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, value);
2108 }
2109 else
2110 {
2111 // send the message for remote dispatching and execution or local queing
2112 NLNET::CMessage __message;
2113
2114 buildMessageFor_onNodeSet(__message, instanceId, attrName, value);
2115
2116 _ModuleProxy->sendModuleMessage(sender, __message);
2117 }
2118 }
2119 // The ServerEditionMode inserts a node on a hl scenario.
2120 void CShareClientEditionItfProxy::onNodeInserted(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value)
2121 {
2122 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2123 {
2124 // immediate local synchronous dispatching
2125 _LocalModuleSkel->onNodeInserted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, position, key, value);
2126 }
2127 else
2128 {
2129 // send the message for remote dispatching and execution or local queing
2130 NLNET::CMessage __message;
2131
2132 buildMessageFor_onNodeInserted(__message, instanceId, attrName, position, key, value);
2133
2134 _ModuleProxy->sendModuleMessage(sender, __message);
2135 }
2136 }
2137 // The ServerEditionMode erases a node on a hl scenario.
2138 void CShareClientEditionItfProxy::onNodeErased(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position)
2139 {
2140 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2141 {
2142 // immediate local synchronous dispatching
2143 _LocalModuleSkel->onNodeErased(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, position);
2144 }
2145 else
2146 {
2147 // send the message for remote dispatching and execution or local queing
2148 NLNET::CMessage __message;
2149
2150 buildMessageFor_onNodeErased(__message, instanceId, attrName, position);
2151
2152 _ModuleProxy->sendModuleMessage(sender, __message);
2153 }
2154 }
2155 // The ServerEditionMode a move node on a hl scenario.
2156 void CShareClientEditionItfProxy::onNodeMoved(NLNET::IModule *sender, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2)
2157 {
2158 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2159 {
2160 // immediate local synchronous dispatching
2161 _LocalModuleSkel->onNodeMoved(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId1, attrName1, position1, instanceId2, attrName2, position2);
2162 }
2163 else
2164 {
2165 // send the message for remote dispatching and execution or local queing
2166 NLNET::CMessage __message;
2167
2168 buildMessageFor_onNodeMoved(__message, instanceId1, attrName1, position1, instanceId2, attrName2, position2);
2169
2170 _ModuleProxy->sendModuleMessage(sender, __message);
2171 }
2172 }
2173 // Updates the client quota
2174 void CShareClientEditionItfProxy::onQuotaUpdated(NLNET::IModule *sender, uint32 maxNpcs, uint32 maxStaticObjects)
2175 {
2176 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2177 {
2178 // immediate local synchronous dispatching
2179 _LocalModuleSkel->onQuotaUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), maxNpcs, maxStaticObjects);
2180 }
2181 else
2182 {
2183 // send the message for remote dispatching and execution or local queing
2184 NLNET::CMessage __message;
2185
2186 buildMessageFor_onQuotaUpdated(__message, maxNpcs, maxStaticObjects);
2187
2188 _ModuleProxy->sendModuleMessage(sender, __message);
2189 }
2190 }
2191 // Updates the client Mode (tester, dm, editor, player) be the speed
2192 void CShareClientEditionItfProxy::onCharModeUpdated(NLNET::IModule *sender, R2::TCharMode mode)
2193 {
2194 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2195 {
2196 // immediate local synchronous dispatching
2197 _LocalModuleSkel->onCharModeUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), mode);
2198 }
2199 else
2200 {
2201 // send the message for remote dispatching and execution or local queing
2202 NLNET::CMessage __message;
2203
2204 buildMessageFor_onCharModeUpdated(__message, mode);
2205
2206 _ModuleProxy->sendModuleMessage(sender, __message);
2207 }
2208 }
2209 // Indicates to the client that an animation has stop (animation, play, test)
2210 void CShareClientEditionItfProxy::onTestModeDisconnected(NLNET::IModule *sender, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType)
2211 {
2212 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2213 {
2214 // immediate local synchronous dispatching
2215 _LocalModuleSkel->onTestModeDisconnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, lastActIndex, animationType);
2216 }
2217 else
2218 {
2219 // send the message for remote dispatching and execution or local queing
2220 NLNET::CMessage __message;
2221
2222 buildMessageFor_onTestModeDisconnected(__message, sessionId, lastActIndex, animationType);
2223
2224 _ModuleProxy->sendModuleMessage(sender, __message);
2225 }
2226 }
2227 // A DSS Message to make a local client tp (because egs can not do it)/
2228 void CShareClientEditionItfProxy::onTpPositionSimulated(NLNET::IModule *sender, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason)
2229 {
2230 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2231 {
2232 // immediate local synchronous dispatching
2233 _LocalModuleSkel->onTpPositionSimulated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, characterId64, x, y, z, scenarioSeason);
2234 }
2235 else
2236 {
2237 // send the message for remote dispatching and execution or local queing
2238 NLNET::CMessage __message;
2239
2240 buildMessageFor_onTpPositionSimulated(__message, sessionId, characterId64, x, y, z, scenarioSeason);
2241
2242 _ModuleProxy->sendModuleMessage(sender, __message);
2243 }
2244 }
2245 // A DSS Message to indicates that the client will be disconnect in secondes./
2246 void CShareClientEditionItfProxy::onKicked(NLNET::IModule *sender, uint32 timeBeforeDisconnection, bool mustKick)
2247 {
2248 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2249 {
2250 // immediate local synchronous dispatching
2251 _LocalModuleSkel->onKicked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), timeBeforeDisconnection, mustKick);
2252 }
2253 else
2254 {
2255 // send the message for remote dispatching and execution or local queing
2256 NLNET::CMessage __message;
2257
2258 buildMessageFor_onKicked(__message, timeBeforeDisconnection, mustKick);
2259
2260 _ModuleProxy->sendModuleMessage(sender, __message);
2261 }
2262 }
2263 // A DSS Message to make to disconnect the client./
2264 void CShareClientEditionItfProxy::onDisconnected(NLNET::IModule *sender)
2265 {
2266 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2267 {
2268 // immediate local synchronous dispatching
2269 _LocalModuleSkel->onDisconnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
2270 }
2271 else
2272 {
2273 // send the message for remote dispatching and execution or local queing
2274 NLNET::CMessage __message;
2275
2276 buildMessageFor_onDisconnected(__message);
2277
2278 _ModuleProxy->sendModuleMessage(sender, __message);
2279 }
2280 }
2281 // Tell to the client that an act begin in nbSeconds
2282 void CShareClientEditionItfProxy::scheduleStartAct(NLNET::IModule *sender, uint32 errorId, uint32 actId, uint32 nbSeconds)
2283 {
2284 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2285 {
2286 // immediate local synchronous dispatching
2287 _LocalModuleSkel->scheduleStartAct(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), errorId, actId, nbSeconds);
2288 }
2289 else
2290 {
2291 // send the message for remote dispatching and execution or local queing
2292 NLNET::CMessage __message;
2293
2294 buildMessageFor_scheduleStartAct(__message, errorId, actId, nbSeconds);
2295
2296 _ModuleProxy->sendModuleMessage(sender, __message);
2297 }
2298 }
2299 // Tell to the client that he is connected in play mode in an animation session
2300 void CShareClientEditionItfProxy::onAnimationModePlayConnected(NLNET::IModule *sender)
2301 {
2302 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2303 {
2304 // immediate local synchronous dispatching
2305 _LocalModuleSkel->onAnimationModePlayConnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
2306 }
2307 else
2308 {
2309 // send the message for remote dispatching and execution or local queing
2310 NLNET::CMessage __message;
2311
2312 buildMessageFor_onAnimationModePlayConnected(__message);
2313
2314 _ModuleProxy->sendModuleMessage(sender, __message);
2315 }
2316 }
2317 // A DSS Message to update the scenario Header
2318 void CShareClientEditionItfProxy::updateScenarioHeader(NLNET::IModule *sender, const R2::TScenarioHeaderSerializer &scenarioHeader)
2319 {
2320 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2321 {
2322 // immediate local synchronous dispatching
2323 _LocalModuleSkel->updateScenarioHeader(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), scenarioHeader);
2324 }
2325 else
2326 {
2327 // send the message for remote dispatching and execution or local queing
2328 NLNET::CMessage __message;
2329
2330 buildMessageFor_updateScenarioHeader(__message, scenarioHeader);
2331
2332 _ModuleProxy->sendModuleMessage(sender, __message);
2333 }
2334 }
2335 // A DSS Message to update discription mission item of a scenario
2336 void CShareClientEditionItfProxy::updateMissionItemsDescription(NLNET::IModule *sender, TSessionId sessionId, const std::vector<R2::TMissionItem> &missionItem)
2337 {
2338 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2339 {
2340 // immediate local synchronous dispatching
2341 _LocalModuleSkel->updateMissionItemsDescription(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, missionItem);
2342 }
2343 else
2344 {
2345 // send the message for remote dispatching and execution or local queing
2346 NLNET::CMessage __message;
2347
2348 buildMessageFor_updateMissionItemsDescription(__message, sessionId, missionItem);
2349
2350 _ModuleProxy->sendModuleMessage(sender, __message);
2351 }
2352 }
2353 // A DSS Message to update the discription of acts (name and positions)
2354 void CShareClientEditionItfProxy::updateActPositionDescriptions(NLNET::IModule *sender, const R2::TActPositionDescriptions &actPositionDescriptions)
2355 {
2356 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2357 {
2358 // immediate local synchronous dispatching
2359 _LocalModuleSkel->updateActPositionDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actPositionDescriptions);
2360 }
2361 else
2362 {
2363 // send the message for remote dispatching and execution or local queing
2364 NLNET::CMessage __message;
2365
2366 buildMessageFor_updateActPositionDescriptions(__message, actPositionDescriptions);
2367
2368 _ModuleProxy->sendModuleMessage(sender, __message);
2369 }
2370 }
2371 // A DSS Message to update the discription of acts (name and positions)
2372 void CShareClientEditionItfProxy::updateUserTriggerDescriptions(NLNET::IModule *sender, const R2::TUserTriggerDescriptions &userTriggerDescriptions)
2373 {
2374 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2375 {
2376 // immediate local synchronous dispatching
2377 _LocalModuleSkel->updateUserTriggerDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userTriggerDescriptions);
2378 }
2379 else
2380 {
2381 // send the message for remote dispatching and execution or local queing
2382 NLNET::CMessage __message;
2383
2384 buildMessageFor_updateUserTriggerDescriptions(__message, userTriggerDescriptions);
2385
2386 _ModuleProxy->sendModuleMessage(sender, __message);
2387 }
2388 }
2389 // A DSS Message to update the discription of acts (name and positions)
2390 void CShareClientEditionItfProxy::onCurrentActIndexUpdated(NLNET::IModule *sender, uint32 actIndex)
2391 {
2392 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2393 {
2394 // immediate local synchronous dispatching
2395 _LocalModuleSkel->onCurrentActIndexUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex);
2396 }
2397 else
2398 {
2399 // send the message for remote dispatching and execution or local queing
2400 NLNET::CMessage __message;
2401
2402 buildMessageFor_onCurrentActIndexUpdated(__message, actIndex);
2403
2404 _ModuleProxy->sendModuleMessage(sender, __message);
2405 }
2406 }
2407 // Update the Talking as list.
2408 void CShareClientEditionItfProxy::updateTalkingAsList(NLNET::IModule *sender, const std::vector<uint32> &botsId)
2409 {
2410 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2411 {
2412 // immediate local synchronous dispatching
2413 _LocalModuleSkel->updateTalkingAsList(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), botsId);
2414 }
2415 else
2416 {
2417 // send the message for remote dispatching and execution or local queing
2418 NLNET::CMessage __message;
2419
2420 buildMessageFor_updateTalkingAsList(__message, botsId);
2421
2422 _ModuleProxy->sendModuleMessage(sender, __message);
2423 }
2424 }
2425 // Update the Incarning list.
2426 void CShareClientEditionItfProxy::updateIncarningList(NLNET::IModule *sender, const std::vector<uint32> &botsId)
2427 {
2428 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2429 {
2430 // immediate local synchronous dispatching
2431 _LocalModuleSkel->updateIncarningList(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), botsId);
2432 }
2433 else
2434 {
2435 // send the message for remote dispatching and execution or local queing
2436 NLNET::CMessage __message;
2437
2438 buildMessageFor_updateIncarningList(__message, botsId);
2439
2440 _ModuleProxy->sendModuleMessage(sender, __message);
2441 }
2442 }
2443 // A message that will be printed an client
2444 void CShareClientEditionItfProxy::systemMsg(NLNET::IModule *sender, const std::string &msgType, const std::string &who, const std::string &msg)
2445 {
2446 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2447 {
2448 // immediate local synchronous dispatching
2449 _LocalModuleSkel->systemMsg(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgType, who, msg);
2450 }
2451 else
2452 {
2453 // send the message for remote dispatching and execution or local queing
2454 NLNET::CMessage __message;
2455
2456 buildMessageFor_systemMsg(__message, msgType, who, msg);
2457
2458 _ModuleProxy->sendModuleMessage(sender, __message);
2459 }
2460 }
2461 // Update the ring access of the client
2462 void CShareClientEditionItfProxy::onRingAccessUpdated(NLNET::IModule *sender, const std::string &ringAccess)
2463 {
2464 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2465 {
2466 // immediate local synchronous dispatching
2467 _LocalModuleSkel->onRingAccessUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ringAccess);
2468 }
2469 else
2470 {
2471 // send the message for remote dispatching and execution or local queing
2472 NLNET::CMessage __message;
2473
2474 buildMessageFor_onRingAccessUpdated(__message, ringAccess);
2475
2476 _ModuleProxy->sendModuleMessage(sender, __message);
2477 }
2478 }
2479 // a message to validate a file waiting to be saved
2480 void CShareClientEditionItfProxy::saveScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted)
2481 {
2482 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2483 {
2484 // immediate local synchronous dispatching
2485 _LocalModuleSkel->saveScenarioFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature, isAccepted);
2486 }
2487 else
2488 {
2489 // send the message for remote dispatching and execution or local queing
2490 NLNET::CMessage __message;
2491
2492 buildMessageFor_saveScenarioFileAccepted(__message, md5, signature, isAccepted);
2493
2494 _ModuleProxy->sendModuleMessage(sender, __message);
2495 }
2496 }
2497 // a message to validate a file waiting to be loaded
2498 void CShareClientEditionItfProxy::loadScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok)
2499 {
2500 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2501 {
2502 // immediate local synchronous dispatching
2503 _LocalModuleSkel->loadScenarioFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, ok);
2504 }
2505 else
2506 {
2507 // send the message for remote dispatching and execution or local queing
2508 NLNET::CMessage __message;
2509
2510 buildMessageFor_loadScenarioFileAccepted(__message, md5, ok);
2511
2512 _ModuleProxy->sendModuleMessage(sender, __message);
2513 }
2514 }
2515 // a message to validate a user component file waiting to be saved
2516 void CShareClientEditionItfProxy::saveUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted)
2517 {
2518 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2519 {
2520 // immediate local synchronous dispatching
2521 _LocalModuleSkel->saveUserComponentFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature, isAccepted);
2522 }
2523 else
2524 {
2525 // send the message for remote dispatching and execution or local queing
2526 NLNET::CMessage __message;
2527
2528 buildMessageFor_saveUserComponentFileAccepted(__message, md5, signature, isAccepted);
2529
2530 _ModuleProxy->sendModuleMessage(sender, __message);
2531 }
2532 }
2533 // a message to validate a user component file waiting to be loaded
2534 void CShareClientEditionItfProxy::loadUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok)
2535 {
2536 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2537 {
2538 // immediate local synchronous dispatching
2539 _LocalModuleSkel->loadUserComponentFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, ok);
2540 }
2541 else
2542 {
2543 // send the message for remote dispatching and execution or local queing
2544 NLNET::CMessage __message;
2545
2546 buildMessageFor_loadUserComponentFileAccepted(__message, md5, ok);
2547
2548 _ModuleProxy->sendModuleMessage(sender, __message);
2549 }
2550 }
2551 // send the header of a multi-part message
2552 void CShareClientEditionItfProxy::multiPartMsgHead(NLNET::IModule *sender, const std::string &msgName, uint32 nbPacket, uint32 size)
2553 {
2554 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2555 {
2556 // immediate local synchronous dispatching
2557 _LocalModuleSkel->multiPartMsgHead(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgName, nbPacket, size);
2558 }
2559 else
2560 {
2561 // send the message for remote dispatching and execution or local queing
2562 NLNET::CMessage __message;
2563
2564 buildMessageFor_multiPartMsgHead(__message, msgName, nbPacket, size);
2565
2566 _ModuleProxy->sendModuleMessage(sender, __message);
2567 }
2568 }
2569 // send a part of a multi-part message
2570 void CShareClientEditionItfProxy::multiPartMsgBody(NLNET::IModule *sender, uint32 partId, uint32 packetSize)
2571 {
2572 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2573 {
2574 // immediate local synchronous dispatching
2575 _LocalModuleSkel->multiPartMsgBody(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), partId, packetSize);
2576 }
2577 else
2578 {
2579 // send the message for remote dispatching and execution or local queing
2580 NLNET::CMessage __message;
2581
2582 buildMessageFor_multiPartMsgBody(__message, partId, packetSize);
2583
2584 _ModuleProxy->sendModuleMessage(sender, __message);
2585 }
2586 }
2587 // send the footer of a multi-part message
2588 void CShareClientEditionItfProxy::multiPartMsgFoot(NLNET::IModule *sender)
2589 {
2590 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2591 {
2592 // immediate local synchronous dispatching
2593 _LocalModuleSkel->multiPartMsgFoot(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
2594 }
2595 else
2596 {
2597 // send the message for remote dispatching and execution or local queing
2598 NLNET::CMessage __message;
2599
2600 buildMessageFor_multiPartMsgFoot(__message);
2601
2602 _ModuleProxy->sendModuleMessage(sender, __message);
2603 }
2604 }
2605 // send an ack messag to the client
2606 void CShareClientEditionItfProxy::ackMsg(NLNET::IModule *sender, uint32 msgId, bool ok)
2607 {
2608 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
2609 {
2610 // immediate local synchronous dispatching
2611 _LocalModuleSkel->ackMsg(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, ok);
2612 }
2613 else
2614 {
2615 // send the message for remote dispatching and execution or local queing
2616 NLNET::CMessage __message;
2617
2618 buildMessageFor_ackMsg(__message, msgId, ok);
2619
2620 _ModuleProxy->sendModuleMessage(sender, __message);
2621 }
2622 }
2623
2624 // Message serializer. Return the message received in reference for easier integration
2625 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_startingScenario(NLNET::CMessage &__message, uint32 charId)
2626 {
2627 __message.setType("RSS1");
2628 nlWrite(__message, serial, charId);
2629
2630
2631 return __message;
2632 }
2633
2634 // Message serializer. Return the message received in reference for easier integration
2635 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, uint32 startingAct, const std::string &errorMsg)
2636 {
2637 __message.setType("RSS2");
2638 nlWrite(__message, serial, ok);
2639 nlWrite(__message, serial, startingAct);
2640 nlWrite(__message, serial, const_cast < std::string& > (errorMsg));
2641
2642
2643 return __message;
2644 }
2645
2646 // Message serializer. Return the message received in reference for easier integration
2647 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5)
2648 {
2649 __message.setType("CUCR");
2650 nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5));
2651
2652
2653 return __message;
2654 }
2655
2656 // Message serializer. Return the message received in reference for easier integration
2657 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onUserComponentUploading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5)
2658 {
2659 __message.setType("CUCU");
2660 nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5));
2661
2662
2663 return __message;
2664 }
2665
2666 // Message serializer. Return the message received in reference for easier integration
2667 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onScenarioUploaded(NLNET::CMessage &__message, const R2::CObjectSerializerClient &hlScenario)
2668 {
2669 __message.setType("CSUA");
2670 nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (hlScenario));
2671
2672
2673 return __message;
2674 }
2675
2676 // Message serializer. Return the message received in reference for easier integration
2677 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeSet(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value)
2678 {
2679 __message.setType("CNSA");
2680 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
2681 nlWrite(__message, serial, const_cast < std::string& > (attrName));
2682 nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (value));
2683
2684
2685 return __message;
2686 }
2687
2688 // Message serializer. Return the message received in reference for easier integration
2689 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeInserted(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value)
2690 {
2691 __message.setType("CNIA");
2692 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
2693 nlWrite(__message, serial, const_cast < std::string& > (attrName));
2694 nlWrite(__message, serial, position);
2695 nlWrite(__message, serial, const_cast < std::string& > (key));
2696 nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (value));
2697
2698
2699 return __message;
2700 }
2701
2702 // Message serializer. Return the message received in reference for easier integration
2703 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeErased(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position)
2704 {
2705 __message.setType("CNEA");
2706 nlWrite(__message, serial, const_cast < std::string& > (instanceId));
2707 nlWrite(__message, serial, const_cast < std::string& > (attrName));
2708 nlWrite(__message, serial, position);
2709
2710
2711 return __message;
2712 }
2713
2714 // Message serializer. Return the message received in reference for easier integration
2715 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeMoved(NLNET::CMessage &__message, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2)
2716 {
2717 __message.setType("CNMA");
2718 nlWrite(__message, serial, const_cast < std::string& > (instanceId1));
2719 nlWrite(__message, serial, const_cast < std::string& > (attrName1));
2720 nlWrite(__message, serial, position1);
2721 nlWrite(__message, serial, const_cast < std::string& > (instanceId2));
2722 nlWrite(__message, serial, const_cast < std::string& > (attrName2));
2723 nlWrite(__message, serial, position2);
2724
2725
2726 return __message;
2727 }
2728
2729 // Message serializer. Return the message received in reference for easier integration
2730 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onQuotaUpdated(NLNET::CMessage &__message, uint32 maxNpcs, uint32 maxStaticObjects)
2731 {
2732 __message.setType("CQU");
2733 nlWrite(__message, serial, maxNpcs);
2734 nlWrite(__message, serial, maxStaticObjects);
2735
2736
2737 return __message;
2738 }
2739
2740 // Message serializer. Return the message received in reference for easier integration
2741 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onCharModeUpdated(NLNET::CMessage &__message, R2::TCharMode mode)
2742 {
2743 __message.setType("CCMU");
2744 nlWrite(__message, serial, mode);
2745
2746
2747 return __message;
2748 }
2749
2750 // Message serializer. Return the message received in reference for easier integration
2751 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onTestModeDisconnected(NLNET::CMessage &__message, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType)
2752 {
2753 __message.setType("CTMD");
2754 nlWrite(__message, serial, sessionId);
2755 nlWrite(__message, serial, lastActIndex);
2756 nlWrite(__message, serialEnum, animationType);
2757
2758
2759 return __message;
2760 }
2761
2762 // Message serializer. Return the message received in reference for easier integration
2763 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onTpPositionSimulated(NLNET::CMessage &__message, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason)
2764 {
2765 __message.setType("CTPPS");
2766 nlWrite(__message, serial, sessionId);
2767 nlWrite(__message, serial, characterId64);
2768 nlWrite(__message, serial, x);
2769 nlWrite(__message, serial, y);
2770 nlWrite(__message, serial, z);
2771 nlWrite(__message, serial, scenarioSeason);
2772
2773
2774 return __message;
2775 }
2776
2777 // Message serializer. Return the message received in reference for easier integration
2778 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onKicked(NLNET::CMessage &__message, uint32 timeBeforeDisconnection, bool mustKick)
2779 {
2780 __message.setType("COK");
2781 nlWrite(__message, serial, timeBeforeDisconnection);
2782 nlWrite(__message, serial, mustKick);
2783
2784
2785 return __message;
2786 }
2787
2788 // Message serializer. Return the message received in reference for easier integration
2789 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onDisconnected(NLNET::CMessage &__message)
2790 {
2791 __message.setType("COD");
2792
2793
2794 return __message;
2795 }
2796
2797 // Message serializer. Return the message received in reference for easier integration
2798 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(NLNET::CMessage &__message, uint32 errorId, uint32 actId, uint32 nbSeconds)
2799 {
2800 __message.setType("SSA1");
2801 nlWrite(__message, serial, errorId);
2802 nlWrite(__message, serial, actId);
2803 nlWrite(__message, serial, nbSeconds);
2804
2805
2806 return __message;
2807 }
2808
2809 // Message serializer. Return the message received in reference for easier integration
2810 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onAnimationModePlayConnected(NLNET::CMessage &__message)
2811 {
2812 __message.setType("OAMC");
2813
2814
2815 return __message;
2816 }
2817
2818 // Message serializer. Return the message received in reference for easier integration
2819 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateScenarioHeader(NLNET::CMessage &__message, const R2::TScenarioHeaderSerializer &scenarioHeader)
2820 {
2821 __message.setType("CUSH");
2822 nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (scenarioHeader));
2823
2824
2825 return __message;
2826 }
2827
2828 // Message serializer. Return the message received in reference for easier integration
2829 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateMissionItemsDescription(NLNET::CMessage &__message, TSessionId sessionId, const std::vector<R2::TMissionItem> &missionItem)
2830 {
2831 __message.setType("CUIT");
2832 nlWrite(__message, serial, sessionId);
2833 nlWrite(__message, serialCont, const_cast < std::vector<R2::TMissionItem>& > (missionItem));
2834
2835
2836 return __message;
2837 }
2838
2839 // Message serializer. Return the message received in reference for easier integration
2840 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateActPositionDescriptions(NLNET::CMessage &__message, const R2::TActPositionDescriptions &actPositionDescriptions)
2841 {
2842 __message.setType("CUAPD");
2843 nlWrite(__message, serialCont, const_cast < R2::TActPositionDescriptions& > (actPositionDescriptions));
2844
2845
2846 return __message;
2847 }
2848
2849 // Message serializer. Return the message received in reference for easier integration
2850 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateUserTriggerDescriptions(NLNET::CMessage &__message, const R2::TUserTriggerDescriptions &userTriggerDescriptions)
2851 {
2852 __message.setType("CUUTD");
2853 nlWrite(__message, serialCont, const_cast < R2::TUserTriggerDescriptions& > (userTriggerDescriptions));
2854
2855
2856 return __message;
2857 }
2858
2859 // Message serializer. Return the message received in reference for easier integration
2860 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onCurrentActIndexUpdated(NLNET::CMessage &__message, uint32 actIndex)
2861 {
2862 __message.setType("CUAIU");
2863 nlWrite(__message, serial, actIndex);
2864
2865
2866 return __message;
2867 }
2868
2869 // Message serializer. Return the message received in reference for easier integration
2870 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateTalkingAsList(NLNET::CMessage &__message, const std::vector<uint32> &botsId)
2871 {
2872 __message.setType("CUTAL");
2873 nlWrite(__message, serialCont, const_cast < std::vector<uint32>& > (botsId));
2874
2875
2876 return __message;
2877 }
2878
2879 // Message serializer. Return the message received in reference for easier integration
2880 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateIncarningList(NLNET::CMessage &__message, const std::vector<uint32> &botsId)
2881 {
2882 __message.setType("CUIL");
2883 nlWrite(__message, serialCont, const_cast < std::vector<uint32>& > (botsId));
2884
2885
2886 return __message;
2887 }
2888
2889 // Message serializer. Return the message received in reference for easier integration
2890 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_systemMsg(NLNET::CMessage &__message, const std::string &msgType, const std::string &who, const std::string &msg)
2891 {
2892 __message.setType("CSM");
2893 nlWrite(__message, serial, const_cast < std::string& > (msgType));
2894 nlWrite(__message, serial, const_cast < std::string& > (who));
2895 nlWrite(__message, serial, const_cast < std::string& > (msg));
2896
2897
2898 return __message;
2899 }
2900
2901 // Message serializer. Return the message received in reference for easier integration
2902 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onRingAccessUpdated(NLNET::CMessage &__message, const std::string &ringAccess)
2903 {
2904 __message.setType("CRAU");
2905 nlWrite(__message, serial, const_cast < std::string& > (ringAccess));
2906
2907
2908 return __message;
2909 }
2910
2911 // Message serializer. Return the message received in reference for easier integration
2912 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_saveScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted)
2913 {
2914 __message.setType("CSSFA");
2915 nlWrite(__message, serial, const_cast < std::string& > (md5));
2916 nlWrite(__message, serial, const_cast < std::string& > (signature));
2917 nlWrite(__message, serial, isAccepted);
2918
2919
2920 return __message;
2921 }
2922
2923 // Message serializer. Return the message received in reference for easier integration
2924 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_loadScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok)
2925 {
2926 __message.setType("CLSFA");
2927 nlWrite(__message, serial, const_cast < std::string& > (md5));
2928 nlWrite(__message, serial, ok);
2929
2930
2931 return __message;
2932 }
2933
2934 // Message serializer. Return the message received in reference for easier integration
2935 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_saveUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted)
2936 {
2937 __message.setType("SUCFA");
2938 nlWrite(__message, serial, const_cast < std::string& > (md5));
2939 nlWrite(__message, serial, const_cast < std::string& > (signature));
2940 nlWrite(__message, serial, isAccepted);
2941
2942
2943 return __message;
2944 }
2945
2946 // Message serializer. Return the message received in reference for easier integration
2947 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_loadUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok)
2948 {
2949 __message.setType("LUCFA");
2950 nlWrite(__message, serial, const_cast < std::string& > (md5));
2951 nlWrite(__message, serial, ok);
2952
2953
2954 return __message;
2955 }
2956
2957 // Message serializer. Return the message received in reference for easier integration
2958 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, const std::string &msgName, uint32 nbPacket, uint32 size)
2959 {
2960 __message.setType("DSS_HEAD");
2961 nlWrite(__message, serial, const_cast < std::string& > (msgName));
2962 nlWrite(__message, serial, nbPacket);
2963 nlWrite(__message, serial, size);
2964
2965
2966 return __message;
2967 }
2968
2969 // Message serializer. Return the message received in reference for easier integration
2970 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 partId, uint32 packetSize)
2971 {
2972 __message.setType("DSS_MSG");
2973 nlWrite(__message, serial, partId);
2974 nlWrite(__message, serial, packetSize);
2975
2976
2977 return __message;
2978 }
2979
2980 // Message serializer. Return the message received in reference for easier integration
2981 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message)
2982 {
2983 __message.setType("DSS_FOOT");
2984
2985
2986 return __message;
2987 }
2988
2989 // Message serializer. Return the message received in reference for easier integration
2990 const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_ackMsg(NLNET::CMessage &__message, uint32 msgId, bool ok)
2991 {
2992 __message.setType("CACKMSG");
2993 nlWrite(__message, serial, msgId);
2994 nlWrite(__message, serial, ok);
2995
2996
2997 return __message;
2998 }
2999
3000 /////////////////////////////////////////////////////////////////
3001 // WARNING : this is a generated file, don't change it !
3002 /////////////////////////////////////////////////////////////////
3003
3004
3005 const CIOSRingItfSkel::TMessageHandlerMap &CIOSRingItfSkel::getMessageHandlers() const
3006 {
3007 static TMessageHandlerMap handlers;
3008 static bool init = false;
3009
3010 if (!init)
3011 {
3012 std::pair < TMessageHandlerMap::iterator, bool > res;
3013
3014 res = handlers.insert(std::make_pair(std::string("SINFAI"), &CIOSRingItfSkel::storeItemNamesForAIInstance_skel));
3015 // if this assert, you have a doubly message name in your interface definition !
3016 nlassert(res.second);
3017
3018 init = true;
3019 }
3020
3021 return handlers;
3022 }
3023 bool CIOSRingItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
3024 {
3025 const TMessageHandlerMap &mh = getMessageHandlers();
3026
3027 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
3028
3029 if (it == mh.end())
3030 {
3031 return false;
3032 }
3033
3034 TMessageHandler cmd = it->second;
3035 (this->*cmd)(sender, message);
3036
3037 return true;
3038 }
3039
3040
3041 void CIOSRingItfSkel::storeItemNamesForAIInstance_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
3042 {
3043 H_AUTO(CIOSRingItfSkel_storeItemNamesForAIInstance_SINFAI);
3044 uint32 aiInstance;
3045 nlRead(__message, serial, aiInstance);
3046 std::vector < TCharMappedInfo > itemInfos;
3047 nlRead(__message, serialCont, itemInfos);
3048 storeItemNamesForAIInstance(sender, aiInstance, itemInfos);
3049 }
3050 // DSS send a list of ring names user item with a AI instance
3051 void CIOSRingItfProxy::storeItemNamesForAIInstance(NLNET::IModule *sender, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos)
3052 {
3053 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
3054 {
3055 // immediate local synchronous dispatching
3056 _LocalModuleSkel->storeItemNamesForAIInstance(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), aiInstance, itemInfos);
3057 }
3058 else
3059 {
3060 // send the message for remote dispatching and execution or local queing
3061 NLNET::CMessage __message;
3062
3063 buildMessageFor_storeItemNamesForAIInstance(__message, aiInstance, itemInfos);
3064
3065 _ModuleProxy->sendModuleMessage(sender, __message);
3066 }
3067 }
3068
3069 // Message serializer. Return the message received in reference for easier integration
3070 const NLNET::CMessage &CIOSRingItfProxy::buildMessageFor_storeItemNamesForAIInstance(NLNET::CMessage &__message, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos)
3071 {
3072 __message.setType("SINFAI");
3073 nlWrite(__message, serial, aiInstance);
3074 nlWrite(__message, serialCont, const_cast < std::vector < TCharMappedInfo >& > (itemInfos));
3075
3076
3077 return __message;
3078 }
3079
3080 }