?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix crash with fame and new player
[ryzomcore.git] / ryzom / server / src / ai_service / commands.cpp
blob10db3a862ab1e699fb3dc680b5b1d200e5272640
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
19 #include "stdpch.h"
20 #include "continent.h"
21 #include "continent_inline.h"
22 #include "ai_mgr.h"
23 #include "ai_grp.h"
24 #include "ai_bot.h"
25 #include "ai_entity_matrix.h"
26 #include "ai_player.h"
27 #include "ai_mgr_fauna.h"
28 #include "ai_grp_fauna.h"
29 #include "ai_grp_npc.h"
30 #include "ai_grp_pet.h"
31 #include "ai_bot_npc.h"
32 #include "mirrors.h"
33 #include "server_share/mission_messages.h"
34 #include "game_share/fame.h"
35 #include "server_share/used_continent.h"
36 #include "ai_outpost.h"
37 #include "script_compiler.h"
38 #include "ais_actions.h"
39 #include "fx_entity_manager.h"
40 #include "ai_script_data_manager.h"
41 #include "commands.h"
42
43 #include "ais_user_models.h"
44
45 extern bool GrpHistoryRecordLog;
46 extern NLLIGO::CLigoConfig LigoConfig;
47
48 using namespace NLMISC;
49 using namespace NLNET;
50 using namespace std;
51 using namespace AITYPES;
52 using namespace AICOMP;
53 using namespace AIVM;
54
55 //////////////////////////////////////////////////////////////////////////////
56 // New set of commands //
57 //////////////////////////////////////////////////////////////////////////////
58
59 //- Generic commands ---------------------------------------------------------
60
61 RYAI_TEMPLATED_COMMAND(listInstances, "display the list of ai instances", "[<filter>]", CAIInstance, buildInstanceList, displayList)
62 RYAI_TEMPLATED_COMMAND(listContinents, "display the list of continents", "[<filter>]", CContinent, buildContinentList, displayList)
63 RYAI_TEMPLATED_COMMAND(listRegions, "display the list of regions", "[<filter>]", CRegion, buildRegionList, displayList)
64 RYAI_TEMPLATED_COMMAND(listCellZones, "display the list of cell zones", "[<filter>]", CCellZone, buildCellZoneList, displayList)
65 RYAI_TEMPLATED_COMMAND(listFamilyBehaviours, "display the list of family behaviours", "[<filter>]", CFamilyBehavior, buildFamilyBehaviorList, displayList)
66 RYAI_TEMPLATED_COMMAND(listOutposts, "display the list of outposts", "[<filter>]", COutpost, buildOutpostList, displayList)
67 RYAI_TEMPLATED_COMMAND(listManagers, "display the list of managers", "[<filter>]", CManager, buildManagerList, displayList)
68 RYAI_TEMPLATED_COMMAND(listNpcManagers, "display the list of managers", "[<filter>]", CManager, buildNpcManagerList, displayList)
69 RYAI_TEMPLATED_COMMAND(listGroups, "display the list of groups", "[<filter>]", CGroup, buildGroupList, displayList)
70 RYAI_TEMPLATED_COMMAND(listBots, "display the list of bots", "[<filter>]", CBot, buildBotList, displayList)
71 RYAI_TEMPLATED_COMMAND(listPlayers, "display the list of players", "[<filter>]", CBotPlayer, buildPlayerList, displayList)
72 RYAI_TEMPLATED_COMMAND(listFaunaPlaces, "display the list of fauna places", "[<filter>]", CAIPlace, buildFaunaPlaceList, displayList)
73
74 RYAI_TEMPLATED_COMMAND(enableFaunaPlace, "enable a fauna place", "[<filter>]", CAIPlace, buildFaunaPlaceList, spawnList)
75 RYAI_TEMPLATED_COMMAND(disableFaunaPlace, "disable a fauna place", "[<filter>]", CAIPlace, buildFaunaPlaceList, despawnList)
76
77
78
79 RYAI_TEMPLATED_COMMAND(displayInstances, "display extensively the list of ai instances", "[<filter>]", CAIInstance, buildInstanceList, displayListEx)
80 RYAI_TEMPLATED_COMMAND(displayContinents, "display extensively the list of continents", "[<filter>]", CContinent, buildContinentList, displayListEx)
81 RYAI_TEMPLATED_COMMAND(displayRegions, "display extensively the list of regions", "[<filter>]", CRegion, buildRegionList, displayListEx)
82 RYAI_TEMPLATED_COMMAND(displayCellZones, "display extensively the list of cell zones", "[<filter>]", CCellZone, buildCellZoneList, displayListEx)
83 RYAI_TEMPLATED_COMMAND(displayFamilyBehaviours, "display extensively the list of family behaviours", "[<filter>]", CFamilyBehavior, buildFamilyBehaviorList, displayListEx)
84 //RYAI_TEMPLATED_COMMAND(displayOutposts, "display extensively the list of outposts", "[<filter>]", COutpost, buildOutpostList, displayListEx)
85 RYAI_TEMPLATED_COMMAND(displayManagers, "display extensively the list of managers", "[<filter>]", CManager, buildManagerList, displayListEx)
86 RYAI_TEMPLATED_COMMAND(displayGroups, "display extensively the list of groups", "[<filter>]", CGroup, buildGroupList, displayListEx)
87 RYAI_TEMPLATED_COMMAND(displayBots, "display extensively the list of bots", "[<filter>]", CBot, buildBotList, displayListEx)
88 RYAI_TEMPLATED_COMMAND(displayPlayers, "display extensively the list of players", "[<filter>]", CBotPlayer, buildPlayerList, displayListEx)
89
90 RYAI_TEMPLATED_COMMAND(spawnInstances, "spawns the ai instances", "[<filter>]", CAIInstance, buildInstanceList, spawnList)
91 //RYAI_TEMPLATED_COMMAND(spawnContinents, "spawns the continents", "[<filter>]", CContinent, buildContinentList, spawnList)
92 //RYAI_TEMPLATED_COMMAND(spawnRegions, "spawns the regions", "[<filter>]", CRegion, buildRegionList, spawnList)
93 //RYAI_TEMPLATED_COMMAND(spawnCellZones, "spawns the cell zones", "[<filter>]", CCellZone, buildCellZoneList, spawnList)
94 //RYAI_TEMPLATED_COMMAND(spawnFamilyBehaviours, "spawns the family behaviours", "[<filter>]", CFamilyBehavior, buildFamilyBehaviorList, spawnList)
95 //RYAI_TEMPLATED_COMMAND(spawnOutposts, "spawns the outposts", "[<filter>]", COutpost, buildOutpostList, spawnList)
96 RYAI_TEMPLATED_COMMAND(spawnManagers, "spawns the managers", "[<filter>]", CManager, buildManagerList, spawnList)
97 RYAI_TEMPLATED_COMMAND(spawnGroups, "spawns the groups", "[<filter>]", CGroup, buildGroupList, spawnList)
98 //RYAI_TEMPLATED_COMMAND(spawnBots, "spawns the bots", "[<filter>]", CBot, buildBotList, spawnList)
99 //RYAI_TEMPLATED_COMMAND(spawnPlayers, "spawns the players", "[<filter>]", CBotPlayer, buildPlayerList, spawnList)
100
101 RYAI_TEMPLATED_COMMAND(despawnInstances, "despawns the ai instances", "[<filter>]", CAIInstance, buildInstanceList, despawnList)
102 //RYAI_TEMPLATED_COMMAND(despawnContinents, "despawns the continents", "[<filter>]", CContinent, buildContinentList, despawnList)
103 //RYAI_TEMPLATED_COMMAND(despawnRegions, "despawns the regions", "[<filter>]", CRegion, buildRegionList, despawnList)
104 //RYAI_TEMPLATED_COMMAND(despawnCellZones, "despawns the cell zones", "[<filter>]", CCellZone, buildCellZoneList, despawnList)
105 //RYAI_TEMPLATED_COMMAND(despawnFamilyBehaviours, "despawns the family behaviours", "[<filter>]", CFamilyBehavior, buildFamilyBehaviorList, despawnList)
106 //RYAI_TEMPLATED_COMMAND(despawnOutposts, "despawns the outposts", "[<filter>]", COutpost, buildOutpostList, despawnList)
107 RYAI_TEMPLATED_COMMAND(despawnManagers, "despawns the managers", "[<filter>]", CManager, buildManagerList, despawnList)
108 RYAI_TEMPLATED_COMMAND(despawnGroups, "despawns the groups", "[<filter>]", CGroup, buildGroupList, despawnList)
109 //RYAI_TEMPLATED_COMMAND(despawnBots, "despawns the bots", "[<filter>]", CBot, buildBotList, despawnList)
110 //RYAI_TEMPLATED_COMMAND(despawnPlayers, "despawns the players", "[<filter>]", CBotPlayer, buildPlayerList, despawnList)
111
112 //- Special commands ---------------------------------------------------------
113
114 NLMISC_COMMAND(search, "search all the data tree for a name part","<name_part>")
115 {
116 if (args.size() != 1)
117 return false;
118
119 {
120 log.displayNL("- Search results in instances ------------------------------------------------");
121 std::deque<CAIInstance*> container;
122 buildInstanceList(container);
123 displayList(log, container, args[0]);
124 }
125
126 {
127 log.displayNL("- Search results in continents -----------------------------------------------");
128 std::deque<CContinent*> container;
129 buildContinentList(container);
130 displayList(log, container, args[0]);
131 }
132
133 {
134 log.displayNL("- Search results in regions --------------------------------------------------");
135 std::deque<CRegion*> container;
136 buildRegionList(container);
137 displayList(log, container, args[0]);
138 }
139
140 {
141 log.displayNL("- Search results in cell zones -----------------------------------------------");
142 std::deque<CCellZone*> container;
143 buildCellZoneList(container);
144 displayList(log, container, args[0]);
145 }
146
147 {
148 log.displayNL("- Search results in family behaviors -----------------------------------------");
149 std::deque<CFamilyBehavior*> container;
150 buildFamilyBehaviorList(container);
151 displayList(log, container, args[0]);
152 }
153
154 {
155 log.displayNL("- Search results in outposts -------------------------------------------------");
156 std::deque<COutpost*> container;
157 buildOutpostList(container);
158 displayList(log, container, args[0]);
159 }
160
161 {
162 log.displayNL("- Search results in managers -------------------------------------------------");
163 std::deque<CManager*> container;
164 buildManagerList(container);
165 displayList(log, container, args[0]);
166 }
167
168 {
169 log.displayNL("- Search results in groups ---------------------------------------------------");
170 std::deque<CGroup*> container;
171 buildGroupList(container);
172 displayList(log, container, args[0]);
173 }
174
175 {
176 log.displayNL("- Search results in bots -----------------------------------------------------");
177 std::deque<CBot*> container;
178 buildBotList(container);
179 displayList(log, container, args[0]);
180 }
181
182 {
183 log.displayNL("- Search results in players --------------------------------------------------");
184 std::deque<CBotPlayer*> container;
185 buildPlayerList(container);
186 displayList(log, container, args[0]);
187 }
188
189 return true;
190 }
191
192 //----------------------------------------------------------------------------
193
194 NLMISC_COMMAND(eventCreateNpcGroup, "create an event npc group", "<aiInstanceId> <nbBots> <sheet> <x> <y> [<dispersionRadius=10m> [<spawnBots=true> [<orientation=random|-360..360> [<name>]]]]")
195 {
196 if (args.size()<5)
197 return false;
198
199 CLogStringWriter stringWriter(&log);
200
201 CAIInstance* aiInstance = NULL;
202 {
203 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
204 if (aiInstanceId>=CAIS::instance().aiinstances().size())
205 {
206 stringWriter.append("Invalid AI Instance Number");
207 return true;
208 }
209 aiInstance = CAIS::instance().aiinstances()[aiInstanceId];
210 if (!aiInstance)
211 {
212 stringWriter.append("AI Instance do not exists");
213 return true;
214 }
215 }
216
217 uint32 nbBots = NLMISC::atoui(args[1].c_str());
218 if (nbBots<=0)
219 {
220 stringWriter.append("invalid bot count");
221 return true;
222 }
223
224 NLMISC::CSheetId sheetId(args[2]);
225 if (sheetId==NLMISC::CSheetId::Unknown)
226 sheetId = args[2] + ".creature";
227 if (sheetId==NLMISC::CSheetId::Unknown)
228 {
229 stringWriter.append("invalid sheet id");
230 return true;
231 }
232
233 double x, y;
234 NLMISC::fromString(args[3], x);
235 NLMISC::fromString(args[4], y);
236
237 double dispersionRadius = 10.;
238 if (args.size()>5)
239 {
240 dispersionRadius = atof(args[5].c_str());
241 if (dispersionRadius<0.)
242 {
243 stringWriter.append("invalid dispersion radius");
244 return true;
245 }
246 }
247
248 bool spawnBots = true;
249 if (args.size()>6)
250 {
251 NLMISC::fromString(args[6], spawnBots);
252 }
253
254 double orientation = 6.666;
255 if (args.size()>7 && args[7] != "random")
256 {
257 NLMISC::fromString(args[7], orientation);
258 orientation = orientation / 360.0 * (NLMISC::Pi * 2.0);
259 }
260
261 std::string botsName;
262 if (args.size()>8) botsName = args[8];
263
264 aiInstance->eventCreateNpcGroup(nbBots, sheetId, CAIVector(x, y), dispersionRadius, spawnBots, orientation, botsName, "");
265
266 return true;
267 }
268
269 //----------------------------------------------------------------------------
270
271 NLMISC_COMMAND(listFxEntities, "", "[<filter>]")
272 {
273 if (args.size()>0)
274 displayList(log, CFxEntityManager::getInstance()->getEntities(), args[0]);
275 else
276 displayList(log, CFxEntityManager::getInstance()->getEntities());
277 return true;
278 }
279
280 //////////////////////////////////////////////////////////////////////////////
281
282 //////////////////////////////////////////////////////////////////////////////
283 // Old set of commands //
284 //////////////////////////////////////////////////////////////////////////////
285
286 // Dump the road/zone connectivity
287 NLMISC_COMMAND(dumpRoadCon, "dump road/cell connectivity graph","<continentName> [<ai instance number = 0>]")
288 {
289 if (args.size() > 2)
290 return false;
291
292 uint instanceIndex = 0;
293
294 if (args.size() == 2)
295 NLMISC::fromString(args[1], instanceIndex);
296
297 if (instanceIndex >= CAIS::instance().AIList().size())
298 {
299 log.displayNL("ai index %u is out of range ! (only %u ai instance)",
300 instanceIndex,
301 CAIS::instance().AIList().size());
302 return false;
303 }
304
305 CAIInstance *aii = CAIS::instance().AIList()[instanceIndex];
306
307 for (uint i=0; i<aii->continents().size(); ++i)
308 {
309 CContinent *cont = aii->continents()[i];
310 if (!cont)
311 continue;
312
313 if ( args.empty()
314 || cont->getName()==args[0])
315 {
316 log.displayRawNL("Dumping connection in '%s' (@ %p):",
317 cont->getName().c_str(),
318 cont);
319
320 CAliasCont<CRegion> &regions = cont->regions();
321
322 for (uint i=0; i<regions.size(); ++i)
323 {
324 CRegion *region = regions[i];
325 if (!region)
326 continue;
327
328 CAliasCont<CCellZone> &cellZones = region->cellZones();
329
330 for (uint i=0; i<cellZones.size(); ++i)
331 {
332 CCellZone *czone = cellZones[i];
333 if (!czone) continue;
334 for (uint j=0; j<czone->cells().size(); ++j)
335 {
336 CCell *cell = czone->cells()[j];
337 if (!cell) continue;
338
339 set<NLMISC::CDbgPtr<CCell> >::iterator first(cell->_NeighbourCells.begin()), last(cell->_NeighbourCells.end());
340 for (; first != last; ++first)
341 {
342 nldebug("Link '%s' => '%s'", cell->getName().c_str(), (*first)->getName().c_str());
343 }
344 }
345 }
346
347
348 for (uint i=0; i<cellZones.size(); ++i)
349 {
350 CCellZone *czone = cellZones[i];
351 if (!czone) continue;
352 for (uint j=0; j<czone->cells().size(); ++j)
353 {
354 CCell *cell = czone->cells()[j];
355 if (!cell) continue;
356 // bound the point into the cell
357 for (uint k=0; k<cell->npcZoneCount(); ++k)
358 {
359 CNpcZone *nz = cell->npcZone(k);
360 if (!nz)
361 continue;
362
363 for (uint l=0; l<nz->roads().size(); ++l)
364 {
365 nldebug("NpcZone '%s' host road '%s'", nz->getAliasTreeOwner().getName().c_str(), nz->roads()[l]->getName().c_str());
366 }
367
368 }
369
370 CAliasCont<CRoad> &roads = cell->roads();
371 for (uint i=0; i<roads.size(); ++i)
372 {
373 CRoad *road = roads[i];
374 if (!road)
375 continue;
376 // clear existing link;
377 nldebug("Road '%s' link from '%s' %s to '%s' %s", road->getName().c_str(),
378 road->startZone().isNULL() ? "none" : road->startZone()->getAliasTreeOwner().getName().c_str(),
379 road->startExternal() ? "(external)" : "",
380 road->endZone().isNULL() ? "none" : road->endZone()->getAliasTreeOwner().getName().c_str(),
381 road->endExternal() ? "(external)" : "");
382 }
383
384 }
385 }
386 }
387
388 }
389 }
390
391 return true;
392 }
393
394 bool dumpContinentImp(uint instanceIndex, const std::string &continentName, NLMISC::CLog &log);
395 // Dump the structure of a dynamic continent
396 NLMISC_COMMAND(dumpContinent, "dump the structure of a continent","<continentName> [<ai instance number = 0>]")
397 {
398 if (args.size() > 2 || args.size() < 1)
399 return false;
400
401 uint instanceIndex = 0;
402
403 if (args.size() == 2)
404 NLMISC::fromString(args[1], instanceIndex);
405
406 if (instanceIndex >= CAIS::instance().AIList().size())
407 {
408 log.displayNL("ai index %u is out of range ! (only %u ai instance)",
409 instanceIndex,
410 CAIS::instance().AIList().size());
411 return false;
412 }
413
414 return dumpContinentImp(instanceIndex, args[0], log);
415 }
416
417 bool dumpContinentImp(uint instanceIndex, const std::string &continentName, NLMISC::CLog &log)
418 {
419 CAIInstance *aii = CAIS::instance().AIList()[instanceIndex];
420
421 for (uint i=0; i<aii->continents().size(); ++i)
422 {
423 CContinent *cont = aii->continents()[i];
424 if (!cont) continue;
425
426 if (cont->getName()==continentName)
427 {
428 log.displayRawNL("Dumping continent '%s' (@ %p):",
429 cont->getName().c_str(),
430 cont);
431
432 for (uint j=0; j<cont->regions().size(); ++j)
433 {
434 CRegion *region = cont->regions()[j];
435 if (!region)
436 {
437 log.displayNL(" +- %u null entry", j);
438 continue;
439 }
440
441 log.displayNL(" +- Region '%s'%s @ %p",
442 region->getName().c_str(),
443 region->getAliasString().c_str(),
444 static_cast<CAliasTreeOwner*>(region));
445
446 for (uint k=0; k<region->cellZones().size(); ++k)
447 {
448 CCellZone *cz = region->cellZones()[k];
449 if (!cz)
450 {
451 log.displayNL(" | +- %u null entry", k);
452 continue;
453 }
454
455 log.displayNL(" | +- CellZone '%s'%s @ %p",
456 cz->getName().c_str(),
457 cz->getAliasString().c_str(),
458 static_cast<CAliasTreeOwner*>(cz));
459
460 for (uint l=0; l<cz->cells().size(); ++l)
461 {
462 CCell *cell = cz->cells()[l];
463 if (!cell)
464 {
465 log.displayNL(" | | +- %u null entry", l);
466 continue;
467 }
468
469 log.displayNL(" | | +- Cell '%s'%s @ %p",
470 cell->getName().c_str(),
471 cell->getAliasString().c_str(),
472 static_cast<CAliasTreeOwner*>(cell));
473
474 for (uint m=0; m<cell->npcZoneCount(); ++m)
475 {
476 CNpcZone *nz = cell->npcZone(m);
477 if (!nz)
478 {
479 log.displayNL(" | | | +- %u null entry", m);
480 continue;
481 }
482
483 // log.displayNL(" | | | +- NpcZone '%s' (alias A:%u @ %p)", nz->getName().c_str(), nz->getAlias(), static_cast<CAliasTreeOwner*>(nz));
484 log.displayNL(" | | | +- NpcZone '%s'%s",
485 nz->getAliasTreeOwner().getName().c_str(),
486 nz->getAliasTreeOwner().getAliasString().c_str());
487
488 }
489
490 for (uint k=0; k<cell->roads().size(); ++k)
491 {
492 CRoad *road = cell->roads()[k];
493 if (!road)
494 {
495 log.displayNL(" | | +- %u null entry", k);
496 continue;
497 }
498
499 log.displayNL(" | | +- Road '%s'%s @ %p",
500 road->getName().c_str(),
501 road->getAliasString().c_str(),
502 static_cast<CAliasTreeOwner*>(road));
503 }
504
505 for (uint m=0; m<cell->faunaZones().size(); ++m)
506 {
507 CFaunaZone *fz = cell->faunaZones()[m];
508 if (!fz)
509 {
510 log.displayNL(" | | | +- %u null entry", m);
511 continue;
512 }
513
514 log.displayNL(" | | | +- FaunaZone '%s'%s @ %p",
515 fz->getName().c_str(),
516 fz->getAliasString().c_str(),
517 static_cast<CAliasTreeOwner*>(fz));
518 }
519 }
520 }
521 }
522
523 // no more to do
524 return true;
525 }
526 }
527
528 log.displayNL("Can't find continent '%s' in ai instance %u",
529 continentName.c_str(),
530 instanceIndex);
531
532 return true;
533 }
534
535
536
537 // Load a collision map
538 NLMISC_COMMAND(loadContinent, "load a continent collision map","<landName>")
539 {
540 if (args.size() != 1)
541 return false;
542
543 CWorldContainer::loadContinent(args[0]);
544
545 return true;
546 }
547
548
549 CAIInstance *currentInstance = NULL;
550
551 NLMISC_COMMAND(createDynamicAIInstance, "Create a new dynamic AIInstance","")
552 {
553 if (args.size() != 1)
554 return false;
555
556 // find an unused continent id
557 uint32 in;
558 NLMISC::fromString(args[0], in);
559 if( !CAIS::instance().getAIInstance(in) )
560 {
561 std::string name= NLMISC::toString("ring_%d",in);
562 const int index = CAIS::instance().createAIInstance(name, in);
563
564 nlinfo("AIInstance %u created for continent '%s' (Instance Index : %u)", in, name.c_str(), index);
565 }
566
567
568 // activate the current AIInstance
569 currentInstance = CAIS::instance().getAIInstance(in); //CAIS::instance().getAIInstance(continentInstanceId);
570 CWorkPtr::aiInstance(currentInstance);
571 return true;
572 }
573
574 NLMISC_COMMAND(createStaticAIInstance, "Create a new static AIInstance for a given continent.","<continentName>")
575 {
576 if (args.size() != 1)
577 return false;
578
579 CUsedContinent &uc = CUsedContinent::instance();
580
581 const uint32 in = uc.getInstanceForContinent(args[0]);
582 if (in == std::numeric_limits<uint32>::max())
583 {
584 nlwarning("The continent '%s' is unknow or not active. Can't create instance, FATAL", args[0].c_str());
585 nlassert(in != ~0);
586 // nlassertex(in != ~0, ("The continent '%s' is unknow or not active. Can't create instance, FATAL", args[0].c_str()));
587 }
588
589 if (!CAIS::instance().getAIInstance(in))
590 {
591 const int index = CAIS::instance().createAIInstance(args[0], in);
592 nlinfo("AIInstance %u created for continent '%s' (Instance Index : %u)",
593 in, args[0].c_str(), index);
594 }
595
596 // activate the current AIInstance
597 currentInstance = CAIS::instance().getAIInstance(in); //CAIS::instance().getAIInstance(continentInstanceId);
598 return true;
599 }
600
601 NLMISC_COMMAND(autoConfig, "Automaticaly load collision map, create AIInstance and load the primitives","")
602 {
603 if (!args.empty())
604 return false;
605
606 CUsedContinent &uc = CUsedContinent::instance();
607
608 log.displayNL("AIS Auto config with %u continents...", uc.getContinents().size());
609 for (uint i=0; i<uc.getContinents().size(); ++i)
610 {
611 const CUsedContinent::TContinentInfo &ci = uc.getContinents()[i];
612
613 // translate logical continent name
614 const string &phyName = uc.getPhysicalContinentName(ci.ContinentName);
615
616 // load the collision map
617 ICommand::execute(toString("loadContinent %s", phyName.c_str()), log);
618 // create the AI Instance
619 ICommand::execute(toString("createStaticAIInstance %s", ci.ContinentName.c_str()), log);
620 // load the active maps
621 ICommand::execute(toString("loadMapsFromCommon %s_all", ci.ContinentName.c_str()), log);
622 }
623
624 return true;
625 }
626
627 bool getParameter(const std::string &srcStr, const std::string &keyWord, std::string &returnStr)
628 {
629 if (srcStr.find(keyWord)!=std::string::npos)
630 {
631 returnStr=srcStr.substr(keyWord.size(),std::string::npos);
632 return true;
633 }
634 returnStr=std::string();
635 return false;
636 }
637
638 //-------------------------------------------------------------------------
639 // set/get the energy value for a family (global version)
640 NLMISC_COMMAND(energy, "set or get the effective energy (affects group type).","[cellZone-<cellZoneName>] [family-<familyName>] [value-<value>] [detailled]")
641 {
642 std::string family;
643 std::string cellZoneName;
644 uint32 value=~0;
645 bool detailled=false;
646
647 CLogStringWriter stringWriter(&log);
648
649 {
650 for (uint32 i=0;i<args.size();i++)
651 {
652 const std::string &str=args[i];
653 string res;
654
655 if (getParameter(str,"cellZone-",res))
656 {
657 cellZoneName=res;
658 }
659
660 if (getParameter(str,"family-",res))
661 {
662 family = res;
663 }
664
665 if (getParameter(str,"value-",res))
666 {
667 float v=float(atof(res.c_str()));
668 clamp(v,0,1);
669 value =uint32(v * ENERGY_SCALE);
670 }
671
672 if (getParameter(str,"detailled",res))
673 {
674 detailled=true;
675 }
676 }
677 }
678
679 const CStringFilter familyFilter(family);
680
681 for (uint i=0; i<CAIS::instance().AIList().size(); ++i)
682 {
683 CAIInstance *aii = CAIS::instance().AIList()[i];
684 if (!aii)
685 continue;
686
687 for (uint j=0; j<aii->continents().size(); ++j)
688 {
689 CContinent *cont = aii->continents()[j];
690 if (!cont)
691 continue;
692
693 for (uint k=0; k<cont->regions().size(); ++k)
694 {
695 CRegion *r = cont->regions()[k];
696 if (!r)
697 continue;
698
699 for (uint l=0; l<r->cellZones().size(); ++l)
700 {
701 CCellZone *cz = r->cellZones()[l];
702 if (!cz)
703 continue;
704
705 if ( !cellZoneName.empty()
706 && cz->getAliasFullName()!=cellZoneName)
707 continue;
708
709 if (value==~0)
710 stringWriter.append("");
711
712 for (uint m=0; m<cz->_Families.size(); ++m)
713 {
714 CFamilyBehavior *fb = cz->_Families[m];
715
716 if (!fb)
717 // TODO
718 // || ( !family.empty()
719 // && familyFilter!=fb->getFamily().getFamilyName()))
720 {
721 continue;
722 }
723
724 if (value==~0) // not for affectation.
725 {
726 fb->displayLogOld (stringWriter, detailled);
727 }
728 else
729 {
730 fb->setEffectiveLevel (value);
731 }
732 }
733 }
734 }
735 }
736 }
737 return true;
738 }
739
740
741 class CDoOnFamily
742 {
743 public:
744 CDoOnFamily()
745 {}
746 virtual ~CDoOnFamily()
747 {}
748 virtual void doOnFamily (CFamilyBehavior *fb) const = 0;
749 virtual void doOnCellZone (CCellZone *cz) const = 0;
750 protected:
751 private:
752 };
753
754
755 bool doOnFamily (const std::vector<std::string> &args, CDoOnFamily *fam)
756 {
757 std::string family;
758 std::string cellZoneName;
759
760 for (uint32 i=0;i<args.size();i++)
761 {
762 const std::string &str=args[i];
763 string res;
764
765 if (getParameter(str,"cellZone-",res))
766 cellZoneName=res;
767
768 if (getParameter(str,"family-",res))
769 family = res;
770 }
771
772 const CStringFilter familyFilter(family);
773
774 FOREACH(aiiIt, CCont<CAIInstance>, CAIS::instance().AIList())
775 {
776 FOREACH(contIt, CCont<CContinent>, (*aiiIt)->continents())
777 {
778 FOREACH(rIt, CCont<CRegion>, (*contIt)->regions())
779 {
780 FOREACH(czIt, CCont<CCellZone>, (*rIt)->cellZones())
781 {
782 if ( !cellZoneName.empty()
783 && czIt->getAliasFullName()!=cellZoneName)
784 continue;
785
786 fam->doOnCellZone(*czIt);
787
788 FOREACH(fb, CCont<CFamilyBehavior>, czIt->_Families)
789 {
790 if ( !family.empty()
791 && familyFilter!=fb->getName())
792 continue;
793
794 fam->doOnFamily(*fb);
795 }
796 }
797 }
798 }
799 }
800 return true;
801 }
802
803
804 class CDoOnFamilyCommand
805 :public CDoOnFamily
806 {
807 public:
808 CDoOnFamilyCommand (const std::vector<std::string> &args, NLMISC::CLog &log)
809 :_stringWriter(&log)
810 {
811 _index=~0;
812 _value=-1;
813 _detailled=false;
814 for (uint32 i=0;i<args.size();i++)
815 {
816 const std::string &str=args[i];
817 string res;
818 if (getParameter(str,"index-",res))
819 NLMISC::fromString(res, _index);
820 if (getParameter(str,"value-",res))
821 _value=float(atof(res.c_str()));
822 _detailled|=getParameter(str,"detailled",res);
823 }
824 }
825
826 void doOnFamily(CFamilyBehavior *fb) const
827 {
828 if (_value==-1) // not for affectation.
829 {
830 fb->displayLogOld (_stringWriter, _detailled);
831 return;
832 }
833 if (_index==~0) // all indexs ?
834 {
835 for (uint32 nrjIndex=0;nrjIndex<4;nrjIndex++)
836 fb->setModifier (_value, nrjIndex);
837 return;
838 }
839 fb->setModifier (_value, (uint32)_index);
840 }
841
842 virtual void doOnCellZone(CCellZone *cz) const
843 {
844 if (_value==-1)
845 _stringWriter.append("");
846 }
847 protected:
848 private:
849 uint32 _index;
850 float _value;
851 bool _detailled;
852 mutable CLogStringWriter _stringWriter;
853 };
854
855
856 NLMISC_COMMAND(energyscalemodifier, "set or get the energy scale (affects group number).","[cellZone-<cellZoneName>] [family-<familyName>] [index-<index>] [value-<value>] [detailled]")
857 {
858 CDoOnFamilyCommand command(args, log);
859 return doOnFamily (args, &command);
860 }
861
862 NLMISC_COMMAND(energyScaleModifier2, "set or get the energy scale (affects group number).","[--cellZone=<cellZoneName>] [--family=<familyName>] [--index=<index>] [--value=<value>] [--detailled]")
863 {
864 std::string cellZoneName;
865 std::string familyName;
866 int index = -1;
867 float value = -1.f;
868 bool detailed = false;
869 for (size_t i=0; i<args.size(); ++i)
870 {
871 std::string const& str = args[i];
872 string res;
873 if (getParameter(str, "--cellZone=", res))
874 cellZoneName = res;
875 if (getParameter(str, "--family=", res))
876 familyName = res;
877 if (getParameter(str, "--index=", res))
878 fromString(res, index);
879 if (getParameter(str, "--value=", res))
880 fromString(res, value);
881 if (str == "--detailed")
882 detailed = true;
883 }
884 if (value<0.f)
885 {
886 // Display
887 std::vector<size_t> widths(10, 0);
888 CFamilyBehavior::checkLogHeadersWidths(widths, index, detailed);
889 FOREACH(itInstance, CCont<CAIInstance>, CAIS::instance().AIList())
890 {
891 FOREACH(itContinent, CCont<CContinent>, itInstance->continents())
892 {
893 FOREACH(itRegion, CCont<CRegion>, itContinent->regions())
894 {
895 FOREACH(itCellZone, CCont<CCellZone>, itRegion->cellZones())
896 {
897 CCellZone* cellZone = *itCellZone;
898 if (!cellZone || !cellZoneName.empty() && cellZone->getName()!=cellZoneName)
899 continue;
900 FOREACH(itFamilyBehavior, CCont<CFamilyBehavior>, cellZone->familyBehaviors())
901 {
902 CFamilyBehavior* familyBehavior = *itFamilyBehavior;
903 if (!familyBehavior || !familyName.empty() && familyBehavior->getName()!=familyName)
904 continue;
905 familyBehavior->checkLogWidths(widths, index, detailed);
906 }
907 }
908 }
909 }
910 }
911 CLogStringWriter stringWriter(&log);
912 CFamilyBehavior::displayLogLine(stringWriter, index, detailed, widths);
913 CFamilyBehavior::displayLogHeaders(stringWriter, index, detailed, widths);
914 CFamilyBehavior::displayLogLine(stringWriter, index, detailed, widths);
915 FOREACH(itInstance, CCont<CAIInstance>, CAIS::instance().AIList())
916 {
917 FOREACH(itContinent, CCont<CContinent>, itInstance->continents())
918 {
919 FOREACH(itRegion, CCont<CRegion>, itContinent->regions())
920 {
921 FOREACH(itCellZone, CCont<CCellZone>, itRegion->cellZones())
922 {
923 CCellZone* cellZone = *itCellZone;
924 if (!cellZone || !cellZoneName.empty() && cellZone->getName()!=cellZoneName)
925 continue;
926 FOREACH(itFamilyBehavior, CCont<CFamilyBehavior>, cellZone->familyBehaviors())
927 {
928 CFamilyBehavior* familyBehavior = *itFamilyBehavior;
929 if (!familyBehavior || !familyName.empty() && familyBehavior->getName()!=familyName)
930 continue;
931 familyBehavior->displayLog(stringWriter, index, detailed, widths);
932 }
933 }
934 }
935 }
936 }
937 CFamilyBehavior::displayLogLine(stringWriter, index, detailed, widths);
938 }
939 else
940 {
941 // Change value
942 }
943 return true;
944 }
945
946
947
948 NLMISC_COMMAND(globalEnergy, "set or get the effective energy for a family.","[<familyName> [<value>]]")
949 {
950 if (args.size() > 2)
951 return false;
952
953 string family;
954
955 CLogStringWriter stringWriter(&log);
956
957 if (args.size() > 0)
958 {
959 family=args[0];
960 }
961
962 uint32 value;
963 if (args.size() == 2)
964 {
965 float v = float(atof(args[1].c_str()));
966 clamp(v,0,1);
967 stringWriter.append("Setting effective energy level for '"+family+"' to "+toString(v));
968 value = uint32(v * ENERGY_SCALE);
969 }
970
971 for (uint i=0; i<CAIS::instance().AIList().size(); ++i)
972 {
973 CAIInstance *aii = CAIS::instance().AIList()[i];
974 if (!aii)
975 continue;
976
977 for (uint j=0; j<aii->continents().size(); ++j)
978 {
979 CContinent *cont = aii->continents()[j];
980 if (!cont)
981 continue;
982
983 for (uint k=0; k<cont->regions().size(); ++k)
984 {
985 CRegion *r = cont->regions()[k];
986 if (!r)
987 continue;
988
989 for (uint l=0; l<r->cellZones().size(); ++l)
990 {
991 CCellZone *cz = r->cellZones()[l];
992 if (!cz)
993 continue;
994
995 stringWriter.append("");
996
997 for (uint m=0; m<cz->_Families.size(); ++m)
998 {
999 CFamilyBehavior *fb = cz->_Families[m];
1000 if (!fb)
1001 continue;
1002
1003 if (args.size() ==0
1004 || ( args.size() == 1
1005 && family == fb->getName())
1006 )
1007 {
1008 fb->displayLogOld (stringWriter, args.size()==1);
1009 continue;
1010 }
1011
1012 if ( args.size() == 2
1013 && family == fb->getName())
1014 {
1015 fb->setEffectiveLevel(value);
1016 }
1017 }
1018 }
1019 }
1020 }
1021 }
1022 return true;
1023 }
1024
1025 //-------------------------------------------------------------------------
1026 // memory report
1027 // NLMISC_COMMAND(statMemory, "generate a memory usage statistic file","<begin|end>")
1028 // {
1029 // if (args.size() != 1)
1030 // return false;
1031 //
1032 // CLogStringWriter stringWriter(&log);
1033 //
1034 // if (args[0] == "begin")
1035 // {
1036 // stringWriter.append("Writing begin memory state in 'memory_report_begin.csv'...");
1037 // NLMEMORY::StatisticsReport("memory_report_begin.csv", false);
1038 // stringWriter.append("Memory stat Done.");
1039 // }
1040 // else if (args[0] == "end")
1041 // {
1042 // stringWriter.append("Writing end memory state report in 'memory_report_end.csv'...");
1043 // NLMEMORY::StatisticsReport("memory_report_end.csv", false);
1044 // stringWriter.append("Memory stat Done.");
1045 // }
1046 // else
1047 // return false;
1048 //
1049 // return true;
1050 // }
1051
1052 //-------------------------------------------------------------------------
1053 // set a group variable
1054
1055 NLMISC_COMMAND(setGroupVar,"display the logic var of the group in the given AI Instance","<aiInstanceId> <group_name|group_alias> <varId> <value>")
1056 {
1057 if (args.size()!=4)
1058 return false;
1059
1060 CGroup *grp = NULL;
1061
1062 CLogStringWriter stringWriter(&log);
1063
1064 CAIInstance *aiInstance=NULL;
1065 {
1066 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
1067 if (aiInstanceId>CAIS::instance().AIList().size())
1068 {
1069 stringWriter.append("Invalid AI Instance Number");
1070 return false;
1071 }
1072 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1073 if (!aiInstance)
1074 {
1075 stringWriter.append("AI Instance do not exists");
1076 return false;
1077 }
1078 }
1079
1080
1081 // first, try to find the group by alias
1082 uint32 alias = NLMISC::atoui(args[1].c_str());
1083 if (alias != 0)
1084 {
1085 grp = aiInstance->findGroup(alias);
1086 }
1087
1088 if (grp == NULL)
1089 {
1090 /// try to find the group bt name
1091 std::vector<CGroup*> grps;
1092 aiInstance->findGroup(grps, args[1]);
1093 if (grps.size() > 1)
1094 {
1095 std::string s;
1096 for (uint i=0; i<grps.size(); ++i)
1097 {
1098 s += NLMISC::toString("%s ", grps[i]->aliasTreeOwner()->getAliasString().c_str());
1099 }
1100 stringWriter.append("More than one group have name '"+args[1]+"', listing alias :");
1101 stringWriter.append(s);
1102
1103 return false;
1104 }
1105 else if (grps.empty())
1106 {
1107 stringWriter.append("No group correspond to name '"+args[1]+"'");
1108 return false;
1109 }
1110 else
1111 {
1112 grp = grps.front();
1113 }
1114 }
1115
1116 // retreive the varID.
1117 // uint32 varId = NLMISC::atoui(args[2].c_str());
1118 NLMISC::TStringId varId=CStringMapper::map(args[2]); // NLMISC::atoui(args[2].c_str());
1119 float value = float(atof(args[3].c_str()));
1120
1121
1122 CStateInstance *stateInstance=grp->getPersistentStateInstance();
1123 stringWriter.append(grp->aliasTreeOwner()->getName()+":"+toString(*varId)+" = "+toString(value)+" (old value : "+ toString(stateInstance->getLogicVar(varId))+" )");
1124 stateInstance->setLogicVar(varId, value);
1125 return true;
1126 }
1127
1128
1129 //-------------------------------------------------------------------------
1130 // display group variable
1131
1132 NLMISC_COMMAND(displayGroupVar,"display the logic var of the group in the given AI Instance","<aIInstanceId> <group_name|group_alias>")
1133 {
1134 if (args.size()!=2)
1135 return false;
1136
1137 CLogStringWriter stringWriter(&log);
1138
1139 CAIInstance *aiInstance=NULL;
1140 {
1141 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
1142 if (aiInstanceId>CAIS::instance().AIList().size())
1143 {
1144 stringWriter.append("Invalid AI Instance Number");
1145 return false;
1146 }
1147 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1148 if (!aiInstance)
1149 {
1150 stringWriter.append("AI Instance do not exists");
1151 return false;
1152 }
1153 }
1154
1155
1156 CGroup *grp = NULL;
1157
1158 // first, try to find the group by alias
1159 uint32 alias = NLMISC::atoui(args[1].c_str());
1160 if (alias != 0)
1161 {
1162 grp = aiInstance->findGroup(alias);
1163 }
1164
1165 if (grp == NULL)
1166 {
1167 /// try to find the group bt name
1168 std::vector<CGroup*> grps;
1169 aiInstance->findGroup(grps, args[1]);
1170 if (grps.size() > 1)
1171 {
1172 std::string s;
1173 for (uint i=0; i<grps.size(); ++i)
1174 {
1175 s += NLMISC::toString("%s ", grps[i]->aliasTreeOwner()->getAliasString().c_str());
1176 }
1177 stringWriter.append("More than one group have name '"+args[1]+"', listing alias :");
1178 stringWriter.append(s);
1179 return false;
1180 }
1181 else if (grps.empty())
1182 {
1183 stringWriter.append("No group correspond to name '"+args[1]+"'");
1184 return false;
1185 }
1186 else
1187 {
1188 grp = grps.front();
1189 }
1190 }
1191
1192 stringWriter.append("Logic var of group '"+grp->aliasTreeOwner()->getName()+"'");
1193
1194
1195 // parser les variables pour outputer le contenu ..
1196
1197 {
1198 const CStateInstance *stateInstance=grp->getPersistentStateInstance();
1199 {
1200 string str;
1201 stateInstance->logicVarsToString(str);
1202 stringWriter.append(str);
1203 }
1204 }
1205
1206 return true;
1207 }
1208
1209
1210
1211 //-------------------------------------------------------------------------
1212 // display the player teams data
1213
1214 NLMISC_COMMAND(displayPlayerTeams,"display all the player teams"," [<-no_detail>]")
1215 {
1216 bool noDetail = false;
1217 if (args.size()>1)
1218 return false;
1219
1220 if ( !args.empty()
1221 && args[args.size()-1]=="-no_detail")
1222 noDetail = true;
1223
1224 CCont<CAIInstance>::iterator it=CAIS::instance().AIList().begin(), itEnd=CAIS::instance().AIList().end();
1225
1226 CLogStringWriter stringWriter(&log);
1227
1228 while (it!=itEnd)
1229 {
1230 std::vector<uint16> teamIds;
1231 CAIInstance *aiInstance=*it;
1232 aiInstance->getPlayerMgr()->getTeamIds(teamIds);
1233
1234 if (teamIds.empty())
1235 {
1236 continue;
1237 }
1238
1239 std::vector<uint16>::iterator first(teamIds.begin()), last(teamIds.end());
1240 for (; first != last; ++first)
1241 {
1242 int id = *first;
1243 {
1244 stringWriter.append("Player Team "+toString(id)+" :");
1245
1246 if (!noDetail)
1247 {
1248 const std::set<TDataSetRow> &team = aiInstance->getPlayerMgr()->getPlayerTeam(uint16(id));
1249 std::set<TDataSetRow>::const_iterator first(team.begin()), last(team.end());
1250 for (; first != last; ++first)
1251 {
1252 stringWriter.append(" Row "+toString((*first).getIndex())+" : "+CMirrors::DataSet->getEntityId(*first).toString());
1253 }
1254 }
1255 }
1256 }
1257 ++it;
1258 }
1259 return true;
1260 }
1261
1262 //-------------------------------------------------------------------------
1263 // set the escrot team ID for a group
1264
1265 NLMISC_COMMAND(setEscortId,"set the escort team id for a group in the given aIInstance","<aIInstanceId> <teamId> <groupAlias>|<groupName>")
1266 {
1267 if (args.size()!=3)
1268 return false;
1269
1270 CLogStringWriter stringWriter(&log);
1271
1272 CAIInstance *aiInstance=NULL;
1273 {
1274 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
1275 if (aiInstanceId>CAIS::instance().AIList().size())
1276 {
1277 stringWriter.append("Invalid AI Instance Number");
1278 return false;
1279 }
1280 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1281 if (!aiInstance)
1282 {
1283 stringWriter.append("AI Instance do not exists");
1284 return false;
1285 }
1286 }
1287
1288 CGroup *grp = NULL;
1289
1290 // first, try to find the group by alias
1291 uint32 alias = NLMISC::atoui(args[2].c_str());
1292 if (alias != 0)
1293 {
1294 grp = aiInstance->findGroup(alias);
1295 }
1296
1297 if (grp == NULL)
1298 {
1299 /// try to find the group bt name
1300 std::vector<CGroup*> grps;
1301 aiInstance->findGroup(grps, args[2]);
1302 if (grps.size() > 1)
1303 {
1304 std::string s;
1305 for (uint i=0; i<grps.size(); ++i)
1306 {
1307 s += NLMISC::toString("%s ", grps[i]->aliasTreeOwner()->getAliasString().c_str());
1308 }
1309 stringWriter.append("More than one group have name '"+args[2]+"', listing alias :");
1310 stringWriter.append(s);
1311 return false;
1312 }
1313 else if (grps.empty())
1314 {
1315 stringWriter.append("No group correspond to name"+args[2]);
1316 return false;
1317 }
1318 else
1319 {
1320 grp = grps.front();
1321 }
1322 }
1323
1324 uint16 teamId = uint16(NLMISC::atoui(args[1].c_str()));
1325 stringWriter.append("Setting escort teamId "
1326 +toString(teamId)
1327 +" on group '"
1328 +args[2]
1329 +"'"
1330 +grp->aliasTreeOwner()->getAliasString().c_str());
1331 grp->setEscortTeamId(teamId);
1332
1333 return true;
1334 }
1335
1336
1337 //-------------------------------------------------------------------------
1338 // buffered commands facility
1339 typedef vector<string> TCommand;
1340 typedef vector<TCommand> TCommandList;
1341 static vector<string> bufferedRetStrings;
1342 void clearBufferedRetStrings()
1343 {
1344 bufferedRetStrings.clear();
1345 }
1346
1347 TCommandList setEventCommands;
1348 TCommandList scriptCommands;
1349 TCommandList scriptCommands2;
1350 TCommandList scriptCommandsBotById;
1351 TCommandList scriptCommandsGroupByName;
1352 TCommandList loadScriptCommands;
1353
1354 bool execSetEvent( CStringWriter& stringWriter, TCommand const& args);
1355 bool execScript( CStringWriter& stringWriter, TCommand const& args);
1356 bool execScript2( CStringWriter& stringWriter, TCommand const& args);
1357 bool execScriptBotById( CStringWriter& stringWriter, TCommand const& args);
1358 bool execScriptGroupByName( CStringWriter& stringWriter, TCommand const& args);
1359 bool execLoadScript(CStringWriter& stringWriter, TCommand const& args);
1360
1361 void execBufferedCommands()
1362 {
1363 vector<string> retStrings;
1364 CArrayStringWriter sw(retStrings);
1365
1366 FOREACHC(it, TCommandList, setEventCommands)
1367 {
1368 execSetEvent(sw, *it);
1369 }
1370 setEventCommands.clear();
1371 FOREACHC(it, TCommandList, scriptCommands)
1372 {
1373 execScript(sw, *it);
1374 }
1375 scriptCommands.clear();
1376 FOREACHC(it, TCommandList, scriptCommands2)
1377 {
1378 execScript2(sw, *it);
1379 }
1380 scriptCommands2.clear();
1381 FOREACHC(it, TCommandList, scriptCommandsBotById)
1382 {
1383 execScriptBotById(sw, *it);
1384 }
1385 scriptCommandsBotById.clear();
1386 FOREACHC(it, TCommandList, scriptCommandsGroupByName)
1387 {
1388 execScriptGroupByName(sw, *it);
1389 }
1390 scriptCommandsGroupByName.clear();
1391 FOREACHC(it, TCommandList, loadScriptCommands)
1392 {
1393 execLoadScript(sw, *it);
1394 }
1395 loadScriptCommands.clear();
1396
1397 // Show ret commands
1398 FOREACHC(strIt, vector<string>, retStrings)
1399 nlwarning(strIt->c_str());
1400 bufferedRetStrings.insert(bufferedRetStrings.end(), retStrings.begin(), retStrings.end());
1401 }
1402
1403
1404 //-------------------------------------------------------------------------
1405 // set a user event on a group
1406 bool execSetEvent(CStringWriter &stringWriter, const vector<string> &args)
1407 {
1408 // Temporize setEvent commands.
1409 if ( args.size() != 3
1410 && !( args.size() == 4
1411 && args[1] == "-no_detail"))
1412 return false;
1413
1414 CAIInstance *aiInstance=NULL;
1415 {
1416 const uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
1417 if (aiInstanceId>CAIS::instance().AIList().size())
1418 {
1419 stringWriter.append("Invalid AI Instance Number");
1420 return false;
1421 }
1422 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1423 if (!aiInstance)
1424 {
1425 stringWriter.append("AI Instance do not exists");
1426 return false;
1427 }
1428 }
1429
1430
1431 bool noDetail = false;
1432
1433 if (args.size() == 4)
1434 noDetail = true;
1435
1436 uint32 eventId = NLMISC::atoui(args[1].c_str());
1437 NLMISC::clamp(eventId, 0u, 9u);
1438
1439 CGroup *grp = NULL;
1440
1441 // first, try to find the group by alias
1442 uint32 alias = NLMISC::atoui(args[2].c_str());
1443 if (alias != 0)
1444 {
1445 grp = aiInstance->findGroup(alias);
1446
1447 if (!grp)
1448 return false;
1449
1450 stringWriter.append("Setting event "+toString(eventId)+" on groups '"+grp->aliasTreeOwner()->getName()+"' ("+toString(grp->getChildIndex())+")");
1451 grp->setEvent(eventId);
1452 return true;
1453 }
1454
1455 std::vector<CGroup*> grps;
1456 if (!grp)
1457 {
1458 /// try to find the group bot name
1459 aiInstance->findGroup(grps, args[2]);
1460 if (grps.size() > 1)
1461 {
1462 if (noDetail)
1463 {
1464 std::string s;
1465 for (uint i=0; i<grps.size(); ++i)
1466 {
1467 s += NLMISC::toString("%s ", grps[i]->aliasTreeOwner()->getAliasString().c_str());
1468 }
1469 stringWriter.append("More than one group have name '"+args[2]+"', listing alias :");
1470 stringWriter.append(s);
1471 return false;
1472 }
1473 }
1474 else if (grps.empty())
1475 {
1476 stringWriter.append("No group correspond to name "+ args[2]);
1477 return false;
1478 }
1479 }
1480
1481 stringWriter.append("Setting event "+toString(eventId)+" on groups '"+args[2]+"'");
1482
1483 for (uint i=0; i<grps.size(); ++i)
1484 grps[i]->setEvent(eventId);
1485
1486 return true;
1487 }
1488
1489 NLMISC_COMMAND(setEvent,"set an event for a group in the given aIInstance [buffered]","<aIInstanceId> [<-no_detail>] <eventId> <groupAlias>|<groupName>")
1490 {
1491 clearBufferedRetStrings();
1492 setEventCommands.push_back(args);
1493 return true;
1494 }
1495
1496 //-------------------------------------------------------------------------
1497 // executes a script on groups matching a specified filter (1st arg)
1498 bool execScript(CStringWriter& stringWriter, TCommand const& args)
1499 {
1500 if (args.size()<1)
1501 return false;
1502
1503 string const& groupName = args[0];
1504 typedef vector<CGroup*> TGroupContainer;
1505 TGroupContainer grps;
1506 {
1507 /// try to find the group bot name
1508 buildFilteredGroupList(grps, groupName);
1509 if (grps.empty())
1510 {
1511 stringWriter.append("No group correspond to name "+ groupName);
1512 return false;
1513 }
1514 }
1515
1516 stringWriter.append("do script on groups '"+groupName+"'");
1517
1518 if (args.size()>1)
1519 {
1520 vector<string> codeLines;
1521 for (size_t i=1; i<args.size(); ++i)
1522 codeLines.push_back(args[i]);
1523
1524 CSmartPtr<const CByteCode> codePtr = CCompiler::getInstance().compileCode(codeLines, "script Command");
1525
1526 FOREACHC(itGrp, TGroupContainer, grps)
1527 {
1528 CGroup* grp = *itGrp;
1529 if (grp->getPersistentStateInstance())
1530 grp->getPersistentStateInstance()->interpretCode(NULL, codePtr);
1531 }
1532 }
1533 else
1534 {
1535 FOREACHC(itGrp, TGroupContainer, grps)
1536 {
1537 CGroup* grp = *itGrp;
1538 if (grp->getPersistentStateInstance())
1539 {
1540 stringWriter.append("Group: "+grp->getFullName());
1541 grp->getPersistentStateInstance()->dumpVarsAndFunctions(stringWriter);
1542 }
1543 }
1544 }
1545 return true;
1546 }
1547
1548 //-------------------------------------------------------------------------
1549 // executes a script on groups containing a bot matching a specified filter (1st arg)
1550 bool execScript2(CStringWriter& stringWriter, TCommand const& args)
1551 {
1552 if (args.size()<1)
1553 return false;
1554
1555 string const& botName = args[0];
1556 typedef set<CGroup*> TGroupContainer;
1557 TGroupContainer grps;
1558 {
1559 vector<CBot*> bots;
1560 /// try to find the bot name
1561 buildFilteredBotList(bots, botName);
1562 if (bots.empty())
1563 {
1564 stringWriter.append("No bot correspond to name "+ botName);
1565 return false;
1566 }
1567 else
1568 {
1569 FOREACH(itBot, vector<CBot*>, bots)
1570 {
1571 CBot* bot = *itBot;
1572 CGroup* group = bot->getOwner();
1573 // if (group->getOwner()==_EventNpcManager) // This would restrict the command to event groups
1574 grps.insert(group);
1575 }
1576 }
1577 }
1578
1579 stringWriter.append("do script on groups containing bot '"+botName+"'");
1580
1581 if (args.size()>1)
1582 {
1583 vector<string> codeLines;
1584 for (size_t i=1; i<args.size(); ++i)
1585 codeLines.push_back(args[i]);
1586
1587 CSmartPtr<const CByteCode> codePtr = CCompiler::getInstance().compileCode(codeLines, "script2 Command");
1588
1589 FOREACHC(itGrp, TGroupContainer, grps)
1590 {
1591 CGroup* grp = *itGrp;
1592 if (grp->getPersistentStateInstance())
1593 grp->getPersistentStateInstance()->interpretCode(NULL, codePtr);
1594 }
1595 }
1596 else
1597 {
1598 FOREACHC(itGrp, TGroupContainer, grps)
1599 {
1600 CGroup* grp = *itGrp;
1601 if (grp->getPersistentStateInstance())
1602 {
1603 stringWriter.append("Group: "+grp->getFullName());
1604 grp->getPersistentStateInstance()->dumpVarsAndFunctions(stringWriter);
1605 }
1606 }
1607 }
1608 return true;
1609 }
1610
1611 //-------------------------------------------------------------------------
1612 // executes a script on groups containing a bot given its entity id
1613 bool execScriptBotById(CStringWriter& stringWriter, TCommand const& args)
1614 {
1615 if (args.size()<2)
1616 return false;
1617
1618 NLMISC::CEntityId botId = NLMISC::CEntityId(args[0]);
1619 if (botId==NLMISC::CEntityId::Unknown)
1620 return false;
1621 CAIEntityPhysical* entity = CAIEntityPhysicalLocator::getInstance()->getEntity(botId);
1622 CSpawnBotNpc* bot = dynamic_cast<CSpawnBotNpc*>(entity);
1623 if (!bot)
1624 return false;
1625 if (!bot->getPersistent().getOwner())
1626 return false;
1627 if (!bot->getPersistent().getOwner()->getPersistentStateInstance())
1628 return false;
1629
1630 vector<string> codeLines;
1631 for (size_t i=1; i<args.size(); ++i)
1632 codeLines.push_back(args[i]);
1633
1634 CSmartPtr<const CByteCode> codePtr = CCompiler::getInstance().compileCode(codeLines, "script2 Command");
1635
1636 bot->getPersistent().getOwner()->getPersistentStateInstance()->interpretCode(NULL, codePtr);
1637
1638 return true;
1639 }
1640
1641 //-------------------------------------------------------------------------
1642 // executes a script on groups containing a bot given its entity id
1643 bool execScriptGroupByName(CStringWriter& stringWriter, TCommand const& args)
1644 {
1645 if (args.size()<2)
1646 return false;
1647
1648 string const& groupName = args[0];
1649 // NLMISC::CEntityId botId = NLMISC::CEntityId(args[0]);
1650 // if (botId==NLMISC::CEntityId::Unknown)
1651 // return false;
1652 CGroupNpc* group = dynamic_cast<CGroupNpc*>(CAliasTreeOwnerLocator::getInstance()->getEntity(groupName));
1653 if (!group)
1654 return false;
1655 if (!group->getPersistentStateInstance())
1656 return false;
1657
1658 vector<string> codeLines;
1659 for (size_t i=1; i<args.size(); ++i)
1660 codeLines.push_back(args[i]);
1661
1662 CSmartPtr<const CByteCode> codePtr = CCompiler::getInstance().compileCode(codeLines, "script2 Command");
1663
1664 group->getPersistentStateInstance()->interpretCode(NULL, codePtr);
1665
1666 return true;
1667 }
1668
1669 NLMISC_COMMAND(getDatasetId,"get datasetid of bots with name matchiong the given filter", "<groupFilter>")
1670 {
1671 if (args.size()!=1)
1672 return false;
1673
1674 string const& botName = args[0];
1675 string DatasetIds;
1676
1677 vector<CBot*> bots;
1678 /// try to find the bot name
1679 buildFilteredBotList(bots, botName);
1680 if (bots.empty())
1681 {
1682 log.displayNL("ERR: No bot correspond to name %s", botName.c_str());
1683 return true;
1684 }
1685 else
1686 {
1687 FOREACH(itBot, vector<CBot*>, bots)
1688 {
1689 CBot* bot = *itBot;
1690 CSpawnBot* spawnBot = bot->getSpawnObj();
1691 if (spawnBot!=NULL)
1692 DatasetIds += spawnBot->dataSetRow().toString()+"|";
1693
1694 }
1695 }
1696 log.displayNL("%s", DatasetIds.c_str());
1697 return true;
1698 }
1699
1700 NLMISC_COMMAND(script,"execute a script for groups matching the given filter [buffered]","<groupFilter> <code>")
1701 {
1702 clearBufferedRetStrings();
1703 scriptCommands.push_back(args);
1704 return true;
1705 }
1706
1707 NLMISC_COMMAND(script2,"execute a script for groups containing a bot matching the given filter [buffered]","<groupFilter> <code>")
1708 {
1709 clearBufferedRetStrings();
1710 scriptCommands2.push_back(args);
1711 return true;
1712 }
1713
1714 NLMISC_COMMAND(scriptHex,"execute a hex-encoded script for a group in the given aIInstance [buffered]","<groupName> <hexcode>")
1715 {
1716 vector<string> _args = args;
1717 _args[1] = scriptHex_decode(_args[1]);
1718 clearBufferedRetStrings();
1719 scriptCommands.push_back(_args);
1720 return true;
1721 }
1722
1723 static const char* hexEncoderTcl =
1724 "proc copy_encoded {} {"
1725 " # Get the args from the text fields"
1726 " set group [ .group.name get 1.0 end ]"
1727 " set script [ .script get 1.0 end ]"
1728 " # Initiate the AIS command"
1729 " set output [concat \"scriptHex\" ${group}]"
1730 " append output \" \""
1731 " # Convert the script itself into an hex string (-1 to remove trailing newline)"
1732 " for {set i 0} {$i < [string length $script]-1} {incr i} {"
1733 " # Get the character"
1734 " set c [string index $script $i]"
1735 " # Get its ascii value"
1736 " scan $c %c n"
1737 " # Print it as 2 hex digits"
1738 " append output [format %02x $n]"
1739 " }"
1740 " # Replace the clipboard with the AIS command"
1741 " clipboard clear"
1742 " clipboard append $output"
1743 "}"
1744 ""
1745 "frame .group"
1746 "pack .group -anchor w -fill x"
1747 "label .group.label -text \"Group:\""
1748 "pack .group.label -side left"
1749 "text .group.name -height 1 -width 70"
1750 "pack .group.name -fill x"
1751 "text .script"
1752 "pack .script -fill both -expand 1"
1753 "button .button -text \"Copy encoded!\""
1754 "pack .button -side bottom"
1755 ""
1756 "bind .button <ButtonPress-1> {"
1757 " copy_encoded"
1758 "}"
1759 "";
1760
1761 NLMISC_COMMAND(hexEncoder,"prints a script that can be used to encode a text for use with scriptHex","<language>")
1762 {
1763 if (args.size()!=1)
1764 return false;
1765
1766 if (args[0]=="tcl")
1767 {
1768 log.displayNL("%s", hexEncoderTcl);
1769 }
1770 else
1771 {
1772 log.displayNL("Invalid language name! Valid languages are: tcl");
1773 }
1774 return true;
1775 }
1776
1777 //-------------------------------------------------------------------------
1778 // set a user event on a group
1779 bool execLoadScript(CStringWriter& stringWriter, vector<string> const& args)
1780 {
1781 if (args.size()!=3)
1782 return false;
1783
1784 CAIInstance* aiInstance = NULL;
1785 {
1786 uint32 const aiInstanceId = NLMISC::atoui(args[0].c_str());
1787 if (aiInstanceId>CAIS::instance().AIList().size())
1788 {
1789 stringWriter.append("Invalid AI Instance Number");
1790 return false;
1791 }
1792 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1793 if (!aiInstance)
1794 {
1795 stringWriter.append("AI Instance do not exists");
1796 return false;
1797 }
1798 }
1799
1800 bool noDetail = false;
1801
1802 string const& groupName = args[1];
1803 std::vector<CGroup*> grps;
1804 {
1805 /// try to find the group bot name
1806 aiInstance->findGroup(grps, groupName);
1807 if (grps.size() > 1)
1808 {
1809 if (noDetail)
1810 {
1811 std::string s;
1812 for (uint i=0; i<grps.size(); ++i)
1813 {
1814 s += NLMISC::toString("%s ", grps[i]->aliasTreeOwner()->getAliasString().c_str());
1815 }
1816 stringWriter.append("More than one group have name '"+groupName+"', listing alias :");
1817 stringWriter.append(s);
1818 return false;
1819 }
1820 }
1821 else if (grps.empty())
1822 {
1823 stringWriter.append("No group correspond to name "+ groupName);
1824 return false;
1825 }
1826 }
1827
1828 stringWriter.append("do script on groups '"+groupName+"'");
1829
1830 try
1831 {
1832 NLMISC::CIFile file(NLMISC::CPath::lookup(args[2]));
1833
1834 vector<string> lines;
1835 while (!file.eof())
1836 {
1837 const size_t bufferSize = 4*1024;
1838 char buffer[bufferSize];
1839 file.getline(buffer, bufferSize);
1840 lines.push_back(buffer);
1841 }
1842 // Compile the buffer
1843 CSmartPtr<const CByteCode> codePtr=CCompiler::getInstance().compileCode(lines, "script Command");
1844
1845 // Interpret the code for each group
1846 FOREACHC(itGrp, vector<CGroup*>, grps)
1847 (*itGrp)->getPersistentStateInstance()->interpretCode(NULL, codePtr);
1848 }
1849 catch (const EPathNotFound &)
1850 {
1851 nlwarning("Path not found while loading AIS script %s", args[2].c_str());
1852 return false;
1853 }
1854 return true;
1855 }
1856
1857 NLMISC_COMMAND(loadScript, "execute a script from a file for a group in the given aIInstance [buffered]", "<aIInstanceId> <groupName> <filename>")
1858 {
1859 clearBufferedRetStrings();
1860 loadScriptCommands.push_back(args);
1861 return true;
1862 }
1863
1864 NLMISC_COMMAND(getInfo,"display returned values of buffered commands","")
1865 {
1866 CLogStringWriter stringWriter(&log);
1867
1868 FOREACHC(strIt, vector<string>, bufferedRetStrings)
1869 {
1870 stringWriter.append(*strIt);
1871 }
1872
1873 return true;
1874 }
1875
1876
1877 //-------------------------------------------------------------------------
1878 // DISPLAYING Managers, Groups and Bots
1879
1880 static void displayNode(const CAIAliasDescriptionNode *node,uint indent=0)
1881 {
1882 nlinfo("%*s- %s %-12s - %s",
1883 indent,
1884 "",
1885 node->getAliasString().c_str(),
1886 getName(node->getType()),
1887 node->fullName().c_str());
1888 for (uint i=0;i<node->getChildCount();++i)
1889 displayNode(node->getChild(i),indent+2);
1890 }
1891
1892 NLMISC_COMMAND(displayNodeTreeMgr,"display node tree for given manager(s)","<manager id>[...]")
1893 {
1894 if(args.size()<1)
1895 return false;
1896
1897 for (uint i=0;i<args.size();++i)
1898 {
1899 CManager* ManagerPtr = CAIS::instance().tryToGetManager(args[i].c_str());
1900 if (ManagerPtr)
1901 {
1902 nlinfo("Manager: %d",i);
1903 displayNode(ManagerPtr->getAliasTreeOwner()->getAliasNode());
1904 continue;
1905 }
1906 nlwarning("Failed to find mgr: %s",args[i].c_str());
1907 }
1908 return true;
1909 }
1910
1911
1912 NLMISC_COMMAND(displayTarget,"display bot target status for given bot(s) or player(s)","<bot id>[...]")
1913 {
1914 if(args.size() <1)
1915 return false;
1916
1917 CLogStringWriter stringWriter(&log);
1918
1919 for (uint i=0;i<args.size();++i)
1920 {
1921 CAIEntityPhysical* EntityPtr = CAIS::instance().tryToGetEntityPhysical(args[i].c_str());
1922 if (!EntityPtr)
1923 {
1924 // log.displayNL("=> can't find entity: %s", args[i].c_str());
1925 continue;
1926 }
1927
1928 CAIEntityPhysical *phys=EntityPtr->getTarget();
1929
1930 if (!phys)
1931 {
1932 log.displayNL("=> bot %s have no target", args[i].c_str());
1933 continue;
1934 }
1935
1936 bool found=false;
1937
1938 switch (phys->getRyzomType())
1939 {
1940 case RYZOMID::npc:
1941 case RYZOMID::creature:
1942 case RYZOMID::pack_animal:
1943 break;
1944 case RYZOMID::player:
1945 log.displayNL("=> target is a player");
1946 break;
1947 default:
1948 {
1949 CSpawnBot* spawnBot=dynamic_cast<CSpawnBot*>(phys);
1950 if (spawnBot)
1951 {
1952 vector<string> strings = spawnBot->getPersistent().getMultiLineInfoString();
1953 FOREACHC(itString, vector<string>, strings)
1954 log.displayNL("%s", itString->c_str());
1955 found=true;
1956 }
1957
1958 }
1959 break;
1960 }
1961
1962 if (!found)
1963 {
1964 log.displayNL("=> can't display information for the target of: %s", args[i].c_str());
1965 }
1966
1967 }
1968 return true;
1969 }
1970
1971 NLMISC_COMMAND(displayVision3x3,"display 3x3 cell vision centred on a given coordinate in the given aIInstance","<aiInstance> <x><y>")
1972 {
1973 if(args.size()!=3)
1974 return false;
1975
1976 CAIInstance *aiInstance=NULL;
1977 {
1978 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
1979 if (aiInstanceId>CAIS::instance().AIList().size())
1980 {
1981 log.displayNL("Invalid AI Instance Number");
1982 return false;
1983 }
1984 aiInstance=CAIS::instance().AIList()[aiInstanceId];
1985 if (!aiInstance)
1986 {
1987 log.displayNL("AI Instance do not exists");
1988 return false;
1989 }
1990 }
1991
1992 double dx, dy;
1993 NLMISC::fromString(args[1], dx);
1994 NLMISC::fromString(args[2], dy);
1995
1996 CAICoord x, y;
1997 x = dx;
1998 y = dy;
1999 log.displayNL("3x3 Vision around (%.3f,%.3f)", x.asDouble(), y.asDouble());
2000
2001 uint32 botCount=0;
2002 uint32 plrCount=0;
2003
2004 CAIVector position(x,y);
2005
2006 {
2007 CAIEntityMatrix<CPersistentOfPhysical>::CEntityIteratorRandom it;
2008 for (it=aiInstance->playerMatrix().beginEntities(CAIS::instance().matrixIterator3x3(),position);!it.end();++it)
2009 {
2010 ++plrCount;
2011 // log.displayNL("=> PLR: %s (%s)", (*it).id().toString().c_str(), (*it).pos().toString().c_str());
2012 if ((*it).isSpawned())
2013 log.displayNL("=> (messageToChange)PLR: %d (%s)", (*it).getSpawnObj()->dataSetRow().getIndex(), (*it).getSpawnObj()->pos().toString().c_str());
2014 }
2015 }
2016
2017 {
2018 CAIEntityMatrix<CPersistentOfPhysical>::CEntityIteratorRandom it;
2019 for (it=aiInstance->botMatrix().beginEntities(CAIS::instance().matrixIterator3x3(),position);!it.end();++it)
2020 {
2021 CPersistentOfPhysical &persRef=(*it);
2022 if (!persRef.isSpawned())
2023 continue;
2024
2025 ++botCount;
2026 CBot* botPtr=NLMISC::safe_cast<CBot*>(&persRef);
2027
2028 if (botPtr->getAliasTreeOwner())
2029 log.displayNL("=> BOT: %s (%s)", botPtr->getAliasTreeOwner()->getName().c_str(), persRef.getSpawnObj()->pos().toString().c_str());
2030 else
2031 log.displayNL("=> BOT: unknown (%s)", persRef.getSpawnObj()->pos().toString().c_str());
2032
2033 // log.displayNL("=> BOT: %s (%s)", (*it).id().toString().c_str(), (*it).pos().toString().c_str());
2034 }
2035 }
2036
2037 log.displayNL("Entites found: %d bots, %d players, total: %d", botCount, plrCount, botCount+plrCount);
2038
2039 return true;
2040 }
2041
2042 NLMISC_COMMAND(displayVisionRadius,"display roughly 'radius' cell vision centred on a given coordinate in the given aIInstance","<aIInstance> <x><y>[<radius>=100]")
2043 {
2044 if ( args.size()!=3
2045 && args.size()!=4 )
2046 return false;
2047
2048 CAIInstance *aiInstance=NULL;
2049 {
2050 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
2051 if (aiInstanceId>CAIS::instance().AIList().size())
2052 {
2053 log.displayNL("Invalid AI Instance Number");
2054 return false;
2055 }
2056 aiInstance=CAIS::instance().AIList()[aiInstanceId];
2057 if (!aiInstance)
2058 {
2059 log.displayNL("AI Instance do not exists");
2060 return false;
2061 }
2062 }
2063
2064 uint32 dist=100;
2065 CAICoord x, y;
2066 x=atof(args[1].c_str());
2067 y=atof(args[2].c_str());
2068 if (args.size()==4)
2069 NLMISC::fromString(args[3], dist);
2070 log.displayNL("%dm Vision around (%.3f,%.3f)", dist, x.asDouble(), y.asDouble());
2071
2072 uint32 botCount=0;
2073 uint32 plrCount=0;
2074
2075 const CAIEntityMatrixIteratorTblLinear *tbl=CAIS::instance().bestLinearMatrixIteratorTbl(dist);
2076
2077 CAIEntityMatrix<CPersistentOfPhysical>::CEntityIteratorLinear it;
2078
2079 CAIVector position(x,y);
2080 for (it=aiInstance->playerMatrix().beginEntities(tbl,position);!it.end();++it)
2081 {
2082 ++plrCount;
2083 const CPersistentOfPhysical& entityPtr = (*it);
2084 const CBotPlayer* const playerPtr=dynamic_cast<const CBotPlayer* const>(&entityPtr);
2085 if (!playerPtr)
2086 continue;
2087
2088 // have to implement players.
2089 #ifdef NL_DEBUG
2090 nlwarning("Not Implemented");
2091 #endif
2092 // log.displayNL("=> PLR: %s (%s)", (*it).id().toString().c_str(), (*it).pos().toString().c_str());
2093 // log.displayNL("=> PLR: %s (%s)", (*it).id().toString().c_str(), (*it).pos().toString().c_str());
2094 }
2095
2096 for (it=aiInstance->botMatrix().beginEntities(tbl,position);!it.end();++it)
2097 {
2098 if ((*it).isSpawned())
2099 {
2100 ++botCount;
2101 // log.displayNL("=> BOT: %s (%s)", (*it).id().toString().c_str(), (*it).pos().toString().c_str());
2102 log.displayNL("=> (messageToChange)BOT: %d (%s)", (*it).getSpawnObj()->dataSetRow().getIndex(), (*it).getSpawnObj()->pos().toString().c_str());
2103 }
2104 }
2105
2106 log.displayNL("Entites found: %d bots, %d players, total: %d", botCount, plrCount, botCount+plrCount);
2107 return true;
2108 }
2109
2110
2111
2112
2113 NLMISC_COMMAND(countEntitesInVisionMatrix,"scan the vision matrix for entities in the given aiInstance","<aiInstance>")
2114 {
2115 if (args.size()!=1)
2116 return false;
2117
2118 CAIInstance *aiInstance=NULL;
2119 {
2120 uint32 aiInstanceId = NLMISC::atoui(args[0].c_str());
2121 if (aiInstanceId>CAIS::instance().AIList().size())
2122 {
2123 log.displayNL("Invalid AI Instance Number");
2124 return false;
2125 }
2126 aiInstance=CAIS::instance().AIList()[aiInstanceId];
2127 if (!aiInstance)
2128 {
2129 log.displayNL("AI Instance do not exists");
2130 return false;
2131 }
2132 }
2133
2134 // build an iterator table for our scan
2135 CAIEntityMatrixIteratorTblRandom tbl;
2136 tbl.push_back(0,0);
2137 for (int i=0;i<256;++i)
2138 {
2139 for (int j=0;j<255;++j)
2140 tbl.push_back(1,0);
2141 if (i<255)
2142 tbl.push_back(-255,1);
2143 }
2144
2145 // some variables
2146 CAIEntityMatrix<CPersistentOfPhysical>::CCellTblIteratorRandom it;
2147 uint32 botCount=0;
2148 uint32 plrCount=0;
2149
2150 CAIVector position(0,0);
2151 // count entities in bot matrix
2152 for (it=aiInstance->botMatrix().beginCells(&tbl,position);!it.end();++it)
2153 {
2154 for (CEntityListLink<CPersistentOfPhysical> *listLink=(*it)->next();listLink!=*it;listLink=listLink->next())
2155 ++botCount;
2156 }
2157
2158 // count entities in player matrix
2159 for (it=aiInstance->playerMatrix().beginCells(&tbl,position);!it.end();++it)
2160 {
2161 for (CEntityListLink<CPersistentOfPhysical> *listLink=(*it)->next();listLink!=*it;listLink=listLink->next())
2162 ++plrCount;
2163 }
2164
2165 // display the results
2166 log.displayNL("Entites found: %d bots, %d players, total: %d", botCount, plrCount, botCount+plrCount);
2167
2168 return true;
2169 }
2170
2171
2172 //-------------------------------------------------------------------------
2173 // DISPLAYING Places
2174
2175 NLMISC_COMMAND(displayPlaces,"display the list of places for specified manager","[<manager id>]")
2176 {
2177 if(args.size() !=1)
2178 return false;
2179
2180 // manager specified so lookup manager by name
2181 CMgrFauna* mgrFaunaPtr = dynamic_cast<CMgrFauna*>(CAIS::instance().tryToGetManager(args[0].c_str()));
2182 if (mgrFaunaPtr==NULL)
2183 return false;
2184
2185 CLogStringWriter stringWriter(&log);
2186
2187 CCont<CGroup >::iterator it = mgrFaunaPtr->groups().begin();
2188 CCont<CGroup >::iterator itEnd = mgrFaunaPtr->groups().end();
2189 while (it!=itEnd)
2190 {
2191 NLMISC::safe_cast<CGrpFauna*>(*it)->displayPlaces(stringWriter);
2192 ++it;
2193 }
2194 return true;
2195 }
2196
2197
2198 //-------------------------------------------------------------------------
2199 // WATCHES FOR TRACKING MGR, GRP & BOT OBJECTS
2200
2201 static std::string WATCH0,WATCH1,WATCH2,WATCH3,WATCH4,
2202 WATCH5,WATCH6,WATCH7,WATCH8,WATCH9;
2203 static std::string *watchStrings[]=
2204 {
2205 &WATCH0,&WATCH1,&WATCH2,&WATCH3,&WATCH4,
2206 &WATCH5,&WATCH6,&WATCH7,&WATCH8,&WATCH9
2207 };
2208
2209 static CAIEntity* watchEntity[sizeof(watchStrings)/sizeof(watchStrings[0])];
2210 static uint watchIdx[sizeof(watchStrings)/sizeof(watchStrings[0])];
2211
2212 NLMISC_VARIABLE(string, WATCH0, "watch string 0");
2213 NLMISC_VARIABLE(string, WATCH1, "watch string 1");
2214 NLMISC_VARIABLE(string, WATCH2, "watch string 2");
2215 NLMISC_VARIABLE(string, WATCH3, "watch string 3");
2216 NLMISC_VARIABLE(string, WATCH4, "watch string 4");
2217 NLMISC_VARIABLE(string, WATCH5, "watch string 5");
2218 NLMISC_VARIABLE(string, WATCH6, "watch string 6");
2219 NLMISC_VARIABLE(string, WATCH7, "watch string 7");
2220 NLMISC_VARIABLE(string, WATCH8, "watch string 8");
2221 NLMISC_VARIABLE(string, WATCH9, "watch string 9");
2222
2223 //
2224 bool FAUNA_GRAPH_USES_DEBUG_TIME = false;
2225 NLMISC_VARIABLE(bool, FAUNA_GRAPH_USES_DEBUG_TIME, "force fauna graph to use local time (for debug)");
2226
2227 // global routine called by the service main update()
2228
2229 void UpdateWatches()
2230 {
2231 // if (!CAIS::initialised())
2232 // return;
2233
2234 for (uint i=0;i<sizeof(watchStrings)/sizeof(watchStrings[0]);++i)
2235 {
2236 if (watchEntity[i])
2237 *watchStrings[i] = watchEntity[i]->getOneLineInfoString();
2238 else
2239 *watchStrings[i] = string("<NULL ENTITY>");
2240 }
2241
2242 }
2243
2244 void removeFromWatch(CAIEntity *entity)
2245 {
2246 for (uint i=0;i<sizeof(watchStrings)/sizeof(watchStrings[0]);++i)
2247 {
2248 if (watchEntity[i]==entity)
2249 watchEntity[i]=NULL;
2250 }
2251
2252 }
2253
2254
2255 NLMISC_COMMAND(setWatch,"setup one of the watch variables","<watch id> <mgr, grp or bot id> [<index>]")
2256 {
2257 if (args.size()!=2 && args.size()!=3)
2258 return false;
2259
2260 uint idx;
2261 NLMISC::fromString(args[0], idx);
2262 if ( toString(idx)!=args[0]
2263 || idx>=sizeof(watchStrings)/sizeof(watchStrings[0]))
2264 return false;
2265
2266 CAIEntity* CAIEntityPtr = CAIS::instance().tryToGetAIEntity(args[1].c_str());
2267
2268 if (!CAIEntityPtr)
2269 return true;
2270
2271 watchEntity[idx]=CAIEntityPtr;
2272
2273 if (args.size()==3)
2274 NLMISC::fromString(args[2], watchIdx[idx]);
2275 else
2276 watchIdx[idx]=0;
2277 return true;
2278 }
2279
2280 static bool setBotRecordHistory(std::vector<std::string> args,bool onOff)
2281 {
2282 if (args.size()==0)
2283 {
2284 CAIInstance* instancePtr = CAIS::instance().AIList().getNextValidChild();
2285 while (instancePtr!=NULL)
2286 {
2287 CManager* mgrPtr = instancePtr->managers().getNextValidChild();
2288 while (mgrPtr!=NULL)
2289 {
2290 CGroup* grpPtr=mgrPtr->getNextValidGroupChild();
2291 while (grpPtr!=NULL)
2292 {
2293 grpPtr->getDebugHistory()->setRecording(onOff);
2294
2295 CBot* botPtr = grpPtr->getNextValidBotChild();
2296 while (botPtr!=NULL)
2297 {
2298 botPtr->getDebugHistory()->setRecording(onOff);
2299
2300 botPtr=grpPtr->getNextValidBotChild(botPtr);
2301 }
2302 grpPtr=mgrPtr->getNextValidGroupChild(grpPtr);
2303 }
2304 mgrPtr=instancePtr->managers().getNextValidChild(mgrPtr);
2305 }
2306 instancePtr=CAIS::instance().AIList().getNextValidChild(instancePtr);
2307 }
2308 }
2309 else
2310 {
2311 CAIInstance* instancePtr = CAIS::instance().AIList().getNextValidChild();
2312 while (instancePtr!=NULL)
2313 {
2314 CManager* mgrPtr = instancePtr->managers().getNextValidChild();
2315 while (mgrPtr!=NULL)
2316 {
2317 CGroup* grpPtr=mgrPtr->getNextValidGroupChild();
2318 while (grpPtr!=NULL)
2319 {
2320 if (onOff)
2321 grpPtr->getDebugHistory()->setRecording(onOff);
2322
2323 CBot* botPtr = grpPtr->getNextValidBotChild();
2324 while (botPtr!=NULL)
2325 {
2326 for (uint i=0;i<args.size();++i)
2327 if (NLMISC::nlstricmp(botPtr->getAliasTreeOwner()->getName(),args[i])==0)
2328 {
2329 botPtr->getDebugHistory()->setRecording(onOff);
2330 }
2331 botPtr=grpPtr->getNextValidBotChild(botPtr);
2332 }
2333 grpPtr=mgrPtr->getNextValidGroupChild(grpPtr);
2334 }
2335 mgrPtr=instancePtr->managers().getNextValidChild(mgrPtr);
2336 }
2337 instancePtr=CAIS::instance().AIList().getNextValidChild(instancePtr);
2338 }
2339 }
2340 return true;
2341 }
2342
2343 NLMISC_COMMAND(botHistoryRecordBegin,"setup history recording for all or named entities","[<bot name> [...]]")
2344 {
2345 return setBotRecordHistory(args,true);
2346 }
2347
2348 NLMISC_COMMAND(botHistoryRecordEnd,"setup history recording for all or named entities","[<bot name> [...]]")
2349 {
2350 return setBotRecordHistory(args,false);
2351 }
2352
2353 NLMISC_COMMAND(botViewHistory,"view recorded history for named entity","<bot name>")
2354 {
2355 if (args.size()==0)
2356 return false;
2357
2358 CAIInstance* instancePtr = CAIS::instance().AIList().getNextValidChild();
2359 while (instancePtr!=NULL)
2360 {
2361 CManager* mgrPtr = instancePtr->managers().getNextValidChild();
2362 while (mgrPtr!=NULL)
2363 {
2364 CGroup* grpPtr=mgrPtr->getNextValidGroupChild();
2365 while (grpPtr!=NULL)
2366 {
2367 CBot* botPtr = grpPtr->getNextValidBotChild();
2368 while (botPtr!=NULL)
2369 {
2370 for (uint i=0;i<args.size();++i)
2371 {
2372 if (NLMISC::nlstricmp(botPtr->getAliasTreeOwner()->getName(),args[i])==0)
2373 {
2374 botPtr->getDebugHistory()->writeAsInfo();
2375 break; // don't need to write info more than one time.
2376 }
2377
2378 }
2379 botPtr=grpPtr->getNextValidBotChild(botPtr);
2380 }
2381 grpPtr=mgrPtr->getNextValidGroupChild(grpPtr);
2382 }
2383 mgrPtr=instancePtr->managers().getNextValidChild(mgrPtr);
2384 }
2385 instancePtr=CAIS::instance().AIList().getNextValidChild(instancePtr);
2386 }
2387 return true;
2388 }
2389
2390
2391 NLMISC_COMMAND(grpHistoryRecordLog,"toggle grp history recorder 'nlinfo' logging","")
2392 {
2393 GrpHistoryRecordLog=!GrpHistoryRecordLog;
2394
2395 nlinfo("GrpHistoryRecordLog: %s",GrpHistoryRecordLog?"ON":"OFF");
2396 return true;
2397 }
2398
2399
2400 //-------------------------------------------------------------------------
2401 // DISPLAYING VISION OF FAUNA GROUPS
2402
2403 NLMISC_COMMAND(displayFaunaGrpVision,"display the vision of a fauna group","<grp id>")
2404 {
2405 return false;
2406 }
2407
2408 //-------------------------------------------------------------------------
2409 // MANIPULATING STATE OF FAUNA GROUPS
2410
2411 NLMISC_COMMAND(advanceGrpState,"advance the group to the next state in its cycle","<grp id>")
2412 {
2413 if(args.size() !=1)
2414 return false;
2415
2416 CGrpFauna *grp=dynamic_cast<CGrpFauna *>(CAIS::instance().tryToGetGroup(args[0].c_str()));
2417 if (!grp)
2418 {
2419 log.displayNL("Failed to identify group: %s",args[0].c_str());
2420 return true;
2421 }
2422 if (!grp->isSpawned())
2423 {
2424 log.displayNL("Group not spawned: %s",args[0].c_str());
2425 }
2426 else
2427 {
2428 grp->getSpawnObj()->resetTimer();
2429 }
2430 return true;
2431 }
2432
2433 NLMISC_COMMAND(setGrpTimers,"set the timer values for a given group","<grp id> <eat time> <rest time>")
2434 {
2435 if(args.size()!=3)
2436 return false;
2437
2438 CGrpFauna *grp=dynamic_cast<CGrpFauna *>(CAIS::instance().tryToGetGroup(args[0].c_str()));
2439 if (!grp)
2440 {
2441 log.displayNL("Failed to identify group: %s",args[0].c_str());
2442 return true;
2443 }
2444
2445 uint32 eatTime, restTime;
2446 NLMISC::fromString(args[1], eatTime);
2447 NLMISC::fromString(args[2], restTime);
2448
2449 if (eatTime<1 || restTime<1)
2450 {
2451 log.displayNL("Invalid time parameters");
2452 return true;
2453 }
2454
2455 grp->setTimer(CGrpFauna::EAT_TIME, eatTime*10);
2456 grp->setTimer(CGrpFauna::REST_TIME, restTime*10);
2457 return true;
2458 }
2459
2460 //-------------------------------------------------------------------------
2461 // RUNNING THE AI UPDATE FOR TESTING OFFLINE
2462
2463 void cbTick();
2464 extern uint ForceTicks;
2465
2466 NLMISC_COMMAND(updateAI,"call CAIS::update() (simulate a tick off-line)","[tick]")
2467 {
2468 if(args.size() >1)
2469 return false;
2470
2471 // if there's an argument make sure its a positive integer
2472 if (args.size()==1)
2473 {
2474 uint tick;
2475 NLMISC::fromString(args[0], tick);
2476 if ((tick < 1) || (toString(tick)!=args[0]))
2477 return false;
2478
2479 ForceTicks = tick;
2480 return true;
2481 }
2482
2483 cbTick();
2484
2485 return true;
2486 }
2487
2488
2489
2490 NLMISC_COMMAND(addPetsToPlayer,"Add some pets specified with a sheet to the specified player.","<player id> <nb pets> <pet_sheet>")
2491 {
2492 if ( args.size() !=3 )
2493 return false;
2494
2495 #ifdef NL_DEBUG
2496 nlstopex(("Not Implemented"));
2497 #endif
2498 return true;
2499 }
2500
2501 //-------------------------------------------------------------------------
2502 // DISPLAYING FIGHT SHEET.
2503
2504 NLMISC_COMMAND(displayFightSheet,"display the sheet","<sheet name>")
2505 {
2506 if (args.size() !=1)
2507 {
2508 log.displayNL("One argument needed");
2509 return false;
2510 }
2511
2512 AISHEETS::ICreatureCPtr sheet = AISHEETS::CSheets::getInstance()->lookup(CSheetId(args[0]));
2513 if (!sheet)
2514 {
2515 log.displayNL("Unknown sheet %s", args[0].c_str());
2516 return true;
2517 }
2518 if (sheet->SheetId()==NLMISC::CSheetId::Unknown)
2519 {
2520 std::string creatureString=args[0]+std::string(".creature");
2521 sheet = /*const_cast<AISHEETS::ICreature*>(*/AISHEETS::CSheets::getInstance()->lookup(CSheetId(creatureString))/*)*/;
2522 }
2523
2524 if (sheet->SheetId()==NLMISC::CSheetId::Unknown)
2525 {
2526 log.displayNL("Failed to identify sheet: %s",args[0].c_str());
2527 return false;
2528 }
2529
2530 log.displayNL("all these values are used to compute a score for a possible new target");
2531 log.displayNL("beware the fact that in this version we used 'level' to represent relative force, it may be changed, so don't take too much time tuning courage");
2532
2533 log.displayNL("- DistModulator [0 n]: %f value=1/(1+distance*DistModulator)", sheet->DistModulator());
2534 log.displayNL("value means the distance sensitivity of the bot, equals to zero means the bot never mind the distance");
2535
2536 log.displayNL("- TargetModulator [0 n]: %f value=1/(1+nbTarget*TargetModulator)", sheet->TargetModulator());
2537 log.displayNL("value means the number of attacker sensitivity of the bot, equals to zero means the bot never mind the number of attackers on the target");
2538
2539 log.displayNL("- ScoreModulator [0 1]: %f score>ScoreModulator", sheet->ScoreModulator());
2540 log.displayNL("value means the minimum value (threshold) needed for the bot to attack, 0 means always, 1 never (also impossible)");
2541
2542 log.displayNL("- FearModulator [0 1]: %f score>FearModulator", sheet->FearModulator());
2543 log.displayNL("value means the minimum value (threshold) needed for the bot to flee, 0 means always, 1 never (also impossible)");
2544
2545 log.displayNL("- LifeLevelModulator [0 1]: %f value=LifeLevelModulator*lifeCoef+(1.f-LifeLevelModulator)*levelCoef", sheet->LifeLevelModulator());
2546 log.displayNL("value means the ratio between the life and level ratio, 1 means life is only take in count, 0 means level only take in count");
2547
2548 log.displayNL("- CourageModulator [-n +n]: %f", sheet->CourageModulator());
2549 log.displayNL("value used to make a bot courageous or feared, -n the bot is feared, +n its courageous");
2550
2551 log.displayNL("- GroupCohesionModulator [0 1]: %f", sheet->GroupCohesionModulator());
2552 log.displayNL("value used to make bots of a group aware of each other, 0 each bot is individual, 1 they fight in group");
2553
2554 log.displayNL("- GroupDispersion [0 1]: %f", sheet->GroupDispersion());
2555 log.displayNL("value used to make bots of a group far or not of each other, 0 each all bots are at the same place, 1 they go everywere in the place");
2556
2557 return true;
2558 }
2559
2560
2561
2562 // all these values are used to compute a score for a possible new target
2563 // beware the fact that in this version we used 'level' to represent relative force, it may be changed, so don't take too much time tuning courage
2564 //
2565 // - DistModulator [0 n]: value=1/(1+distance*DistModulator)
2566 // value means the distance sensitivity of the bot, equals to zero means the bot never mind the distance
2567 //
2568 // - TargetModulator [0 n]: value=1/(1+nbTarget*TargetModulator)
2569 // value means the number of attacker sensitivity of the bot, equals to zero means the bot never mind the number of attackers on the target
2570 //
2571 // - ScoreModulator [0 1]: score>ScoreModulator
2572 // value means the minimum value (threshold) needed for the bot to attack, 0 means always, 1 never (also impossible)
2573 //
2574 // - FearModulator [0 1]: score>FearModulator
2575 // value means the minimum value (threshold) needed for the bot to flee, 0 means always, 1 never (also impossible)
2576 //
2577 // - LifeLevelModulator [0 1]: value=LifeLevelModulator*lifeCoef+(1.f-LifeLevelModulator)*levelCoef
2578 // value means the ratio between the life and level ratio, 1 means life is only take in count, 0 means level only take in count
2579 //
2580 // - CourageModulator [-n +n]:
2581 // value used to make a bot courageous or feared, -n the bot is feared, +n its courageous
2582 //
2583 // - GroupCohesionModulator [0 1]:
2584 // value used to make bots of a group aware of each other, 0 each bot is individual, 1 they fight in group
2585 /*
2586 NLMISC_COMMAND(setFightSheet,"change a value in the fight sheet","<sheet name> <value name> <value> (use name without 'modulator', ex: 'Dist')")
2587 {
2588 if (args.size() !=3)
2589 {
2590 log.displayNL("three argument needed");
2591 return false;
2592 }
2593
2594 AISHEETS::ICreature *sheet=const_cast<AISHEETS::CCreature*>(AISHEETS::CSheets::getInstance()->lookup(CSheetId(args[0])));
2595 if (sheet->SheetId==NLMISC::CSheetId::Unknown)
2596 {
2597 std::string creatureString=args[0]+std::string(".creature");
2598 sheet=const_cast<AISHEETS::ICreature*>(AISHEETS::CSheets::getInstance()->lookup(CSheetId(creatureString)));
2599 }
2600
2601 if (sheet->SheetId==NLMISC::CSheetId::Unknown)
2602 {
2603 log.displayNL("Failed to identify sheet: %s",args[0].c_str());
2604 return false;
2605 }
2606
2607 float value = float(atof(args[2].c_str()));
2608
2609 if (NLMISC::nlstricmp(args[1].c_str(), "dist")==0)
2610 {
2611 if (value<0)
2612 {
2613 log.displayNL("Failed, out of bounds, values accepted are [0 +n]");
2614 return false;
2615 }
2616 sheet->DistModulator=value;
2617 log.displayNL("Done, DistModulator=%f", value);
2618 return true;
2619 }
2620
2621 if (NLMISC::nlstricmp(args[1].c_str(), "target")==0)
2622 {
2623 if (value<0)
2624 {
2625 log.displayNL("Failed, out of bounds, values accepted are [0 +n]");
2626 return false;
2627 }
2628 sheet->TargetModulator=value;
2629 log.displayNL("Done, TargetModulator=%f", value);
2630 return true;
2631 }
2632
2633 if (NLMISC::nlstricmp(args[1].c_str(), "score")==0)
2634 {
2635 if (value<0 || value>1)
2636 {
2637 log.displayNL("Failed, out of bounds, values accepted are [0 +1]");
2638 return false;
2639 }
2640 sheet->ScoreModulator=value;
2641 log.displayNL("Done, ScoreModulator=%f", value);
2642 return true;
2643 }
2644
2645 if (NLMISC::nlstricmp(args[1].c_str(), "fear")==0)
2646 {
2647 if (value<0 || value>1)
2648 {
2649 log.displayNL("Failed, out of bounds, values accepted are [0 +1]");
2650 return false;
2651 }
2652 sheet->FearModulator=value;
2653 log.displayNL("Done, FearModulator=%f", value);
2654 return true;
2655 }
2656
2657 if (NLMISC::nlstricmp(args[1].c_str(), "LifeLevel")==0)
2658 {
2659 if (value<0 || value>1)
2660 {
2661 log.displayNL("Failed, out of bounds, values accepted are [0 +1]");
2662 return false;
2663 }
2664 sheet->LifeLevelModulator=value;
2665 log.displayNL("Done, LifeLevelModulator=%f", value);
2666 return true;
2667 }
2668
2669 if (NLMISC::nlstricmp(args[1].c_str(), "Courage")==0)
2670 {
2671 sheet->CourageModulator=value;
2672 log.displayNL("Done, CourageModulator=%f", value);
2673 return true;
2674 }
2675
2676 if (NLMISC::nlstricmp(args[1].c_str(), "GroupCohesion")==0)
2677 {
2678 if (value<0 || value>1)
2679 {
2680 log.displayNL("Failed, out of bounds, values accepted are [0 +1]");
2681 return false;
2682 }
2683 sheet->GroupCohesionModulator=value;
2684 log.displayNL("Done, GroupCohesionModulator=%f", value);
2685 return true;
2686 }
2687
2688 if (NLMISC::nlstricmp(args[1].c_str(), "GroupDispersion")==0)
2689 {
2690 if (value<0 || value>1)
2691 {
2692 log.displayNL("Failed, out of bounds, values accepted are [0 +1]");
2693 return false;
2694 }
2695 sheet->GroupDispersion=value;
2696 log.displayNL("Done, GroupDispersion=%f", value);
2697 return true;
2698 }
2699
2700 log.displayNL("Failed to identify %s", args[1].c_str());
2701 return false;
2702 }
2703 */
2704 static void botSetPosition(CBot* bot, std::vector<std::string> const& args, std::string const& botid, float x, float y, uint z, NLMISC::CLog& log)
2705 {
2706 CSpawnBot* spawnBot = bot->getSpawnObj();
2707 if (spawnBot!=NULL)
2708 {
2709 std::string botname = bot->getAliasTreeOwner()->getName();
2710 NLMISC::CEntityId eid = spawnBot->getEntityId();
2711 std::string eidstr = eid.toString();
2712 if (botid=="*" || (botname!="")&&(botname.find(botid)!=std::string::npos) || eidstr.find(botid)!=std::string::npos)
2713 {
2714 CAIPosMirror p = spawnBot->pos();
2715 if (args.size()>0)
2716 {
2717 if (args.size()==3)
2718 z = p.h();
2719 spawnBot->setPos(CAIPos(x, y, z, p.theta()));
2720 }
2721 p = spawnBot->pos();
2722 if (botname!="")
2723 log.displayNL("Bot position for %s %s is %f;%f;%d", eidstr.c_str(), botname.c_str(), p.x().asDouble(), p.y().asDouble(), p.h());
2724 else
2725 log.displayNL("Bot position for %s is %f;%f;%d", eidstr.c_str(), p.x().asDouble(), p.y().asDouble(), p.h());
2726 }
2727 }
2728 }
2729
2730 static void botSetPosition(CGroup* grp, std::vector<std::string> const& args, std::string const& botid, float x, float y, uint z, NLMISC::CLog& log)
2731 {
2732 FOREACH (itBot, CCont<CBot>, grp->bots())
2733 {
2734 botSetPosition(*itBot, args, botid, x, y, z, log);
2735 }
2736 }
2737
2738 static void botSetPosition(CManager* mgr, std::vector<std::string> const& args, std::string const& botid, float x, float y, uint z, NLMISC::CLog& log)
2739 {
2740 FOREACH (itGroup, CCont<CGroup>, mgr->groups())
2741 {
2742 botSetPosition(*itGroup, args, botid, x, y, z, log);
2743 }
2744 }
2745
2746 NLMISC_COMMAND(botSetPosition,"set the position of one or several bots","<eid> [<x> <y> [<z>]]")
2747 {
2748 if (args.size()!=1 && args.size()!=3 && args.size()!=4)
2749 return false;
2750
2751 std::string botid = args[0];
2752 float x = 0.f;
2753 float y = 0.f;
2754 uint z = 0;
2755 if (args.size()>1)
2756 {
2757 x = (float)atof(args[1].c_str());
2758 y = (float)atof(args[2].c_str());
2759 if (args.size()==4)
2760 NLMISC::fromString(args[3], z);
2761 }
2762
2763 // For each bot
2764 FOREACH (itInstance, CCont<CAIInstance>, CAIS::instance().AIList())
2765 {
2766 FOREACH (itManager, CCont<CManager>, itInstance->managers())
2767 {
2768 botSetPosition(*itManager, args, botid, x, y, z, log);
2769 }
2770 FOREACH (itCont, CCont<CContinent>, itInstance->continents())
2771 {
2772 FOREACH (itRegion, CCont<CRegion>, itCont->regions())
2773 {
2774 FOREACH (itCellZone, CCont<CCellZone>, itRegion->cellZones())
2775 {
2776 FOREACH (itFamilyBehavior, CCont<CFamilyBehavior>, itCellZone->familyBehaviors())
2777 {
2778 botSetPosition(itFamilyBehavior->mgrNpc(), args, botid, x, y, z, log);
2779 botSetPosition(itFamilyBehavior->mgrFauna(), args, botid, x, y, z, log);
2780 }
2781 }
2782 }
2783 }
2784 }
2785 return true;
2786 }
2787
2788 NLMISC_COMMAND(helpAboutId, "display a short explanation about id used in ai commands", "")
2789 {
2790 log.displayNL("AI Identifier are a string composed as follow :");
2791 log.displayNL(" [AIS_<serice_id>:]{[<instance_idx>][:mgr_idx][:grp_idx][:bot_idx] | dyn_<cont_idx>[:<region_idx>][:<cellzone_idx>][:<family_idx>][:fauna|:npc]}");
2792 log.displayNL(" e.g. : - AIS_138:1:2:3:4 for a 'static' bot");
2793 log.displayNL(" - AIS_138:dyn_0:2:3:4:npc for a 'dynmaic' npc manager");
2794 log.displayNL("The initial 'AIS_<serivce_id>:' is optional.");
2795 log.displayNL("Most of the commands that need an AI id support 'multi selection' by specifying only part of the id.");
2796 return true;
2797 }
2798
2799 NLMISC_COMMAND(despawnEntity, "despawn an entity.","[entityId]")
2800 {
2801 if (args.size()!=1)
2802 return false;
2803
2804 const std::string &entityStr=args[0];
2805 const CEntityId entity(entityStr.c_str());
2806
2807 const TDataSetRow dataSetRow=TheDataset.getDataSetRow(entity);
2808
2809 CAIEntityPhysical *const phys=CAIS::instance().getEntityPhysical(dataSetRow);
2810
2811 if (!phys) { return true;}
2812
2813 switch(phys->getRyzomType())
2814 {
2815 case RYZOMID::creature:
2816 case RYZOMID::npc:
2817 {
2818 CSpawnBot *const bot=safe_cast<CSpawnBot*>(phys);
2819 if (!bot)
2820 break;
2821
2822 bot->getPersistent().getGroup().bots().removeChildByIndex(bot->getPersistent().getChildIndex());
2823 }
2824 break;
2825 case RYZOMID::pack_animal:
2826 {
2827 CSpawnBotPet *const pet=safe_cast<CSpawnBotPet*>(phys);
2828 if (!pet)
2829 break;
2830
2831 pet->getPersistent().setDespawn();
2832 }
2833 break;
2834 default:
2835 break;
2836 }
2837
2838 return true;
2839 }
2840
2841 /* Unload a primitive file
2842 * Unreference all the managers and the regions that are registered for this file.
2843 */
2844 NLMISC_COMMAND(unloadPrimitiveFile,"unload a primitive file","<file name>")
2845 {
2846 if (args.size()!=1)
2847 return false;
2848
2849 // Get the string ID
2850 const NLMISC::TStringId stringId=NLMISC::CStringMapper::map(CFile::getFilenameWithoutExtension(CFile::getFilename(args[0])));
2851
2852 uint managerUnreferenced = 0;
2853 uint continentUnreferenced = 0;
2854
2855 // Parse AI instance
2856 CAIInstance *aiInstance = CWorkPtr::aiInstance();
2857 if (aiInstance)
2858 {
2859 // Parse managers
2860 uint i;
2861 for (i=0; i<aiInstance->managers().size(); i++)
2862 {
2863 CSmartPtr<CManager> manager=aiInstance->managers()[i];
2864 if (manager)
2865 {
2866 // Remove this manager
2867 if (manager->isRegisteredForFile (stringId))
2868 {
2869 aiInstance->managers().removeChildByIndex (i);
2870 managerUnreferenced++;
2871
2872 // Check the pointer is not referenced anymore
2873 nlassert (manager->getRefCount() == 1);
2874 }
2875 }
2876 }
2877
2878 // Parse continents
2879 for (i=0; i<aiInstance->continents().size(); i++)
2880 {
2881 CContinent *continent=aiInstance->continents()[i];
2882 if (continent)
2883 {
2884 // Parse regions
2885 uint j;
2886 for (j=0; j<continent->regions().size(); j++)
2887 {
2888 CSmartPtr<CRegion> region=continent->regions()[j];
2889 if (region)
2890 {
2891 // Remove this region
2892 if (region->isRegisteredForFile (stringId))
2893 {
2894 continent->regions().removeChildByIndex (j);
2895 continentUnreferenced++;
2896
2897 // Check the pointer is not referenced anymore
2898 nlassert (region->getRefCount() == 1);
2899 }
2900 }
2901 }
2902 }
2903 }
2904 aiInstance=CAIS::instance().AIList().getNextValidChild(aiInstance);
2905 uint32 primAlias = LigoConfig.getFileStaticAliasMapping(CFile::getFilename(args[0]));
2906 nldebug("<unloadPrimitiveFile> Sending alias '%u' to AIS for custom data range deletion", primAlias);
2907 CAIUserModelManager::getInstance()->deleteCustomDataByPrimAlias(primAlias);
2908 log.displayNL("unloadPrimitiveFile %s : %d manager removed, %d region removed", args[0].c_str(), managerUnreferenced, continentUnreferenced);
2909 }
2910 else
2911 log.displayNL("unloadPrimitiveFile failed : no active ai instance");
2912
2913 return true;
2914 }
2915
2916 //////////////////////////////////////////////////////////////////////////////
2917 // Bug simulation //
2918 //////////////////////////////////////////////////////////////////////////////
2919
2920 static bool bugSimulationInited = false;
2921 static bool bugSimulationTextInited = false;
2922 static int const bugSimulationCount = 10;
2923 static bool simulateBugs[bugSimulationCount];
2924 static char const* simulateBugTexts[bugSimulationCount];
2925
2926 inline
2927 static void initBugSimulations()
2928 {
2929 if (!bugSimulationInited)
2930 {
2931 bugSimulationInited = true;
2932 for (int i=0; i<bugSimulationCount; ++i)
2933 {
2934 simulateBugs[i] = false;
2935 }
2936 }
2937 }
2938
2939 inline
2940 static void initBugSimulationTexts()
2941 {
2942 if (!bugSimulationTextInited)
2943 {
2944 bugSimulationTextInited = true;
2945 for (int i=0; i<bugSimulationCount; ++i)
2946 simulateBugTexts[i] = "[No bug with this id] ";
2947
2948 simulateBugTexts[0] = "Bots didn't use range weapons ";
2949 simulateBugTexts[1] = "Assign. a string var in another group ";
2950 simulateBugTexts[2] = "Destination reach detection was delayed ";
2951 simulateBugTexts[3] = "Npc grp behav. wasn't updtd often enough ";
2952 simulateBugTexts[4] = "User event only worked in AI instance 0 ";
2953 simulateBugTexts[5] = "Mektoubs following in Water ";
2954 simulateBugTexts[6] = "When looted, fauna respawned immediately ";
2955 simulateBugTexts[7] = "Added a member init. in normal profile ";
2956 simulateBugTexts[8] = "Repulsion vector calc. was misordered ";
2957 }
2958 }
2959
2960 inline
2961 static char const* simulateBugText(int bugId)
2962 {
2963 initBugSimulations();
2964 if (bugId>=0 && bugId<bugSimulationCount)
2965 return simulateBugTexts[bugId];
2966 else
2967 return NULL;
2968 }
2969
2970 /// Past this declaration where needed
2971 extern bool simulateBug(int bugId);
2972
2973 bool simulateBug(int bugId)
2974 {
2975 initBugSimulations();
2976 if (bugId>=0 && bugId<bugSimulationCount)
2977 return simulateBugs[bugId];
2978 else
2979 return false;
2980 }
2981
2982 NLMISC_COMMAND(simulateBug, "simulate an old AIS bug; command is one of 'list', 'enable', 'disable'; enable and disable take as command_arg the id of the bug to simulate","<command> [<command_arg>]")
2983 {
2984
2985 if (args.size()>=1)
2986 {
2987 if (args[0] == "list")
2988 {
2989 if (args.size()==1)
2990 {
2991 initBugSimulations();
2992 initBugSimulationTexts();
2993 log.displayNL("Bug simulations");
2994 log.displayNL("Id|Description |State");
2995 for (int i=0; i<bugSimulationCount; ++i)
2996 {
2997 log.displayNL("%02d|%s|%s", i, simulateBugText(i), simulateBugs[i]?"on":"off");
2998 }
2999 return true;
3000 }
3001 }
3002 else if (args[0] == "enable")
3003 {
3004 if (args.size()==2)
3005 {
3006 initBugSimulations();
3007 if (args[1]=="all")
3008 {
3009 for (int i=0; i<bugSimulationCount; ++i)
3010 simulateBugs[i] = true;
3011 }
3012 else
3013 {
3014 sint i;
3015 NLMISC::fromString(args[1], i);
3016 if (i>=0 && i<bugSimulationCount)
3017 simulateBugs[i] = true;
3018 else
3019 log.displayNL("No bug simulation with id %02d", i);
3020 }
3021 return true;
3022 }
3023 }
3024 else if (args[0] == "disable")
3025 {
3026 if (args.size()==2)
3027 {
3028 initBugSimulations();
3029 if (args[1]=="all")
3030 {
3031 for (sint i=0; i<bugSimulationCount; ++i)
3032 simulateBugs[i] = false;
3033 }
3034 else
3035 {
3036 sint i;
3037 NLMISC::fromString(args[1], i);
3038 if (i>=0 && i<bugSimulationCount)
3039 simulateBugs[i] = false;
3040 else
3041 log.displayNL("No bug simulation with id %02d", i);
3042 }
3043 return true;
3044 }
3045 }
3046 }
3047 return false;
3048 }
3049
3050
3051 static void displayTime(const CRyzomTime &rt, NLMISC::CLog &log)
3052 {
3053 std::string result;
3054 result = NLMISC::toString("hh:mm = %d:%d; ", (int) floorf(rt.getRyzomTime()) , (int) floorf(60.f * fmodf(rt.getRyzomTime(), 1.f)));
3055 log.displayNL(result.c_str());
3056 uint32 month = rt.getRyzomMonth();
3057 MONTH::EMonth monthInCycle = rt.getRyzomMonthInCurrentCycle();
3058 std::string monthName = MONTH::toString((MONTH::EMonth) monthInCycle);
3059 uint32 dayOfMonth = rt.getRyzomDayOfMonth();
3060 std::string dayName = WEEKDAY::toString((WEEKDAY::EWeekDay) rt.getRyzomDayOfWeek());
3061 result = NLMISC::toString("mm:dd:yy = %d:%d:%d (%s:%s)",
3062 (int) (month + 1),
3063 (int) (dayOfMonth + 1),
3064 (int) rt.getRyzomYear(),
3065 monthName.c_str(),
3066 dayName.c_str());
3067 log.displayNL(result.c_str());
3068 log.displayNL("day of year = %d/%d", (int) (rt.getRyzomDayOfYear() + 1), (int) RYZOM_YEAR_IN_DAY);
3069 log.displayNL("season = %d/4 (%s)", (int) rt.getRyzomSeason() + 1, EGSPD::CSeason::toString(rt.getRyzomSeason()).c_str());
3070 }
3071
3072 NLMISC_COMMAND(time, "Display current time.", "<>")
3073 {
3074 if (!args.empty()) return false;
3075 const CRyzomTime &rt = CTimeInterface::getRyzomTime();
3076 displayTime(rt, log);
3077 return true;
3078 }
3079
3080 NLMISC_COMMAND(localTime, "Display current local time (debug time).", "<>")
3081 {
3082 if (!args.empty()) return false;
3083 const CRyzomTime &rt = CTimeInterface::getRyzomDebugTime();
3084 displayTime(rt, log);
3085 return true;
3086 }
3087
3088
3089 struct CRyzomDate
3090 {
3091 float Time;
3092 uint Day;
3093 uint Year;
3094 };
3095
3096 static void getRyzomDebugDate(CRyzomDate &rd)
3097 {
3098 const CRyzomTime &rt = CTimeInterface::getRyzomDebugTime();
3099 rd.Time = rt.getRyzomTime();
3100 rd.Day = rt.getRyzomDayOfYear();
3101 rd.Year = rt.getRyzomYear();
3102 }
3103
3104 static void setRyzomDebugDate(CRyzomDate &rd)
3105 {
3106 CRyzomTime &rt = CTimeInterface::getRyzomDebugTime();
3107 rt.updateRyzomClock((uint32) (rd.Time * RYZOM_HOURS_IN_TICKS) + (rd.Day + rd.Year * RYZOM_YEAR_IN_DAY) * RYZOM_DAY_IN_TICKS);
3108 }
3109
3110 NLMISC_COMMAND(setDebugHour, "set the current debug hour", "<hour>")
3111 {
3112 if (args.size() != 1) return false;
3113 sint hour;
3114 if (!fromString(args[0], hour)) return false;
3115 CRyzomDate rd;
3116 getRyzomDebugDate(rd);
3117 rd.Time = fmodf(rd.Time, 1.f) + (float) hour;
3118 setRyzomDebugDate(rd);
3119 return true;
3120 }
3121
3122 NLMISC_COMMAND(setDebugDayOfYear, "set the current debug day of year (first day has index 1)", "<day>")
3123 {
3124 if (args.size() != 1) return false;
3125 sint day;
3126 if (!fromString(args[0], day)) return false;
3127 CRyzomDate rd;
3128 getRyzomDebugDate(rd);
3129 rd.Day = day - 1; // for the user, days start at '1'
3130 setRyzomDebugDate(rd);
3131 return true;
3132 }
3133
3134 //
3135 // setPersistentVar setname:varName value
3136 //
3137 NLMISC_COMMAND(setPersistentVar, "sets an AI script persistent var", "<command> [<command_arg>]")
3138 {
3139 if (args.size() == 2)
3140 {
3141 std::string varName = args[0].c_str();
3142 std::string value = args[1].c_str();
3143
3144 CAIScriptDataManager::getInstance()->setVar(varName, value);
3145
3146 log.displayNL("Var '%s' set to '%s'", varName.c_str(), value.c_str());
3147 return true;
3148 }
3149
3150 return false;
3151 }
3152
3153 //
3154 // listPersistentVar
3155 //
3156 NLMISC_COMMAND(listPersistentVar, "display all persistent vars", "")
3157 {
3158 if (!args.empty()) return false;
3159
3160 const CPersistentVariables &persistentVar = CAIScriptDataManager::getInstance()->getPersistentVariables();
3161
3162 const TVariableSets &variableSet = persistentVar.getVariableSet();
3163
3164 for (TVariableSets::const_iterator i = variableSet.begin(); i != variableSet.end(); ++i)
3165 {
3166 log.displayNL("#Set: '%s'#", i->first.c_str());
3167 for (TVariables::const_iterator j = i->second.Variables.begin(); j != i->second.Variables.end(); ++j)
3168 {
3169 log.displayNL("Name: '%s' -- Value: '%s'", j->first.c_str(), j->second.c_str());
3170 }
3171 }
3172
3173 return true;
3174 }
3175
3176
3177 //
3178 // getPersistentVar setname:varname
3179 //
3180 NLMISC_COMMAND(getPersistentVarAsString, "get a persistent ai var", "")
3181 {
3182 if (args.size() == 1)
3183 {
3184 std::string varName = args[0];
3185
3186 std::string value = CAIScriptDataManager::getInstance()->getVar_s(varName);
3187 log.displayNL("Variable '%s' has value '%s'", varName.c_str(), value.c_str() );
3188 return true;
3189 }
3190
3191 return false;
3192 }
3193
3194 //
3195 // getPersistentVar setname:varname
3196 //
3197 NLMISC_COMMAND(getPersistentVarAsFloat, "get a persistent ai var", "")
3198 {
3199 if (args.size() == 1)
3200 {
3201 std::string varName = args[0];
3202
3203 float value = CAIScriptDataManager::getInstance()->getVar_f(varName);
3204 nlinfo("Variable '%s' has value '%f'", varName.c_str(), value );
3205 return true;
3206 }
3207
3208 return false;
3209 }
3210
3211 NLMISC_COMMAND(deletePersistentVar, "deletes an AI script persistent var", "")
3212 {
3213 if (args.size() == 1)
3214 {
3215 std::string varName = args[0].c_str();
3216
3217 CAIScriptDataManager::getInstance()->deleteVar(varName);
3218
3219 log.displayNL("Var '%s' deleted", varName.c_str());
3220 return true;
3221 }
3222
3223 return false;
3224 }
3225
3226
3227 //----------------------------------------------------------------------------