ryzom/server/src/ai_share/ai_wrapper_server.cpp

   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 // includes
  19 //-----------------------------------------------------------------------------
  20
  21 #include "stdpch.h"
  22
  23 #include "game_share/ai_wrapper.h"
  24
  25 #include "../ai_share/ai_share.h"
  26
  27 #include "game_share/persistent_data.h"
  28
  29 #include "ai_primitive_parser.h"
  30
  31 using namespace R2;
  32 using namespace NLLIGO;
  33 using namespace NLNET;
  34 using namespace NLMISC;
  35
  36 namespace R2
  37 {
  38         NLLIGO::CLigoConfig * LigoConfigPtr;
  39 }
  40
  41 void CAiWrapperServer::init(NLLIGO::CLigoConfig *  ligoConfig)
  42 {
  43         const char* CLASS_FILE_NAME="world_editor_classes.xml";
  44
  45         if ( ! CPrimitiveContext::instance().CurrentLigoConfig )
  46         {
  47
  48                 CPrimitiveContext::instance().CurrentLigoConfig = R2::LigoConfigPtr;
  49                 // Read the ligo primitive class file
  50         //      NLLIGO::Register();
  51
  52         }
  53
  54         AI_SHARE::init(R2::LigoConfigPtr);
  55 }
  56
  57 void CAiWrapperServer::streamToPdr(NLMISC::IStream& stream, const std::string& primName, CPersistentDataRecord& pdr)
  58 {
  59         H_AUTO_INST( streamToPdr );
  60         CAIPrimitiveParser::init(&pdr);
  61         AI_SHARE::parsePrimStream(stream, primName.c_str());
  62         CAIPrimitiveParser::release();
  63 }
  64
  65 void CAiWrapperServer::primsToPdr(NLLIGO::CPrimitives *prims, const std::string& primName, CPersistentDataRecord& pdr)
  66 {
  67         H_AUTO_INST( primsToPdr );
  68         CAIPrimitiveParser::init(&pdr);
  69         AI_SHARE::parsePrimNoStream(prims, primName.c_str());
  70         CAIPrimitiveParser::release();
  71 }
  72
  73 void CAiWrapperServer::pdrToFile(CPersistentDataRecord& pdr, const std::string& pdrName)
  74 {
  75         CAIPrimitiveParser::init(&pdr);
  76         CAIPrimitiveParser::getInstance().writeFile(pdrName.c_str());
  77         CAIPrimitiveParser::release();
  78 }
  79
  80 void CAiWrapperServer::fileToPdr(const std::string& pdrName, CPersistentDataRecord& pdr)
  81 {
  82         CAIPrimitiveParser::init(&pdr);
  83         CAIPrimitiveParser::getInstance().readFile(pdrName.c_str());
  84         CAIPrimitiveParser::release();
  85 }
  86
  87 void CAiWrapperServer::displayPdr( CPersistentDataRecord& pdr)
  88 {
  89         CAIPrimitiveParser::init(&pdr);
  90         CAIPrimitiveParser::getInstance().display();
  91         CAIPrimitiveParser::release();
  92 }
  93
  94 void CAiWrapperServer::clearPdr( CPersistentDataRecord& pdr)
  95 {
  96         CAIPrimitiveParser::init(&pdr);
  97         CAIPrimitiveParser::getInstance().clear();
  98         CAIPrimitiveParser::release();
  99 }
 100
 101 void CAiWrapperServer::primitiveFileToPdr(const std::string& primitiveName, CPersistentDataRecord& pdr)
 102 {
 103         pdr.clear();
 104         CAIPrimitiveParser::init(&pdr);
 105         AI_SHARE::parsePrimFile(primitiveName.c_str());
 106         CAIPrimitiveParser::release();
 107 }
 108
 109 void CAiWrapperServer::stopTest(TSessionId sessionId, uint32 aiInstanceId)
 110 {
 111         nldebug("Stop Test in session %u (aiInstance %u)", sessionId.asInt(), aiInstanceId);
 112         CMessage msgout("R2_STOPLIVE");
 113         bool isBase = true;
 114
 115         msgout.serial(aiInstanceId);
 116         msgout.serial(isBase);
 117         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 118 }
 119
 120 void CAiWrapperServer::startTest(TSessionId sessionId, uint32 aiInstanceId,  CPersistentDataRecord& pdr)
 121 {
 122
 123         nldebug("Start Test in session %u (aiInstance %u)", sessionId.asInt(), aiInstanceId);
 124         uint32 totalDataSize = pdr.totalDataSize();
 125         char* dest = new char[totalDataSize];
 126         if (!pdr.toBuffer(dest, totalDataSize))
 127         {
 128                 nlwarning("can't serialise data");
 129                 return;
 130         }
 131
 132         {
 133                 CMessage msgout("R2_GOLIVE");
 134                 bool isBase = true;
 135                 msgout.serial(sessionId);
 136                 msgout.serial(aiInstanceId);
 137                 msgout.serial(isBase);
 138                 msgout.serial(totalDataSize);
 139                 msgout.serialBuffer (reinterpret_cast<uint8*>(dest), totalDataSize);
 140                 CUnifiedNetwork::getInstance()->send("AIS",msgout);
 141         }
 142 }
 143
 144 void CAiWrapperServer::startInstance(TSessionId sessionId, uint32 aiInstanceId)
 145 {
 146         nldebug("Start Instance in session %u (aiInstance %u)", sessionId.asInt(), aiInstanceId);
 147         nlinfo("R2An: startInstance %u", aiInstanceId);
 148         CMessage msgout("R2_STARTINSTANCE");
 149         msgout.serial(aiInstanceId);
 150         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 151
 152 }
 153
 154 void CAiWrapperServer::stopAct(TSessionId sessionId, uint32 aiInstanceId)
 155 {
 156         nldebug("Stop Act in session %u (aiInstance %u)", sessionId.asInt(), aiInstanceId);
 157         CMessage msgout("R2_STOPLIVE");
 158         msgout.serial(aiInstanceId);
 159         bool isBase = false;
 160         msgout.serial(isBase);
 161         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 162 }
 163
 164 void CAiWrapperServer::startAct(TSessionId sessionId, uint32 aiInstanceId, CPersistentDataRecord& pdr)
 165 {
 166         nldebug("Start Act in session %u (aiInstance %u)", sessionId.asInt(), aiInstanceId);
 167         uint32 totalDataSize = pdr.totalDataSize();
 168         char* dest = new char[totalDataSize];
 169         if (!pdr.toBuffer(dest, totalDataSize))
 170         {
 171                 nlwarning("can't serialise data");
 172                 return;
 173         }
 174
 175         {
 176                 CMessage msgout("R2_GOLIVE");
 177                 bool isBase = false;
 178                 msgout.serial(sessionId);
 179                 msgout.serial(aiInstanceId);
 180                 msgout.serial(isBase);
 181                 msgout.serial(totalDataSize);
 182                 msgout.serialBuffer (reinterpret_cast<uint8*>(dest), totalDataSize);
 183                 CUnifiedNetwork::getInstance()->send("AIS",msgout);
 184         }
 185 }
 186
 187 void CAiWrapperServer::setAggroRange(NLMISC::CEntityId entityId, float range)
 188 {
 189         CMessage msgout("EXEC_COMMAND");
 190         std::string command = NLMISC::toString("eventSetNpcGroupAggroRange %s %f", entityId.toString().c_str(), range);
 191         msgout.serial(command);
 192         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 193 }
 194
 195 namespace
 196 {
 197         static std::string aliasToString(uint32 alias)
 198         {
 199                 uint32 staticPart = alias >> 20;
 200                 uint32 dynPart = alias  &  ((1 << 21)-1);
 201                 return NLMISC::toString("(A:%u:%u)", staticPart, dynPart);
 202         }
 203 }
 204
 205 void CAiWrapperServer::despawnEntity(NLMISC::CEntityId entityId, uint32 alias)
 206 {
 207         uint32 messageVersion = 1;
 208         uint32 nbString=2;
 209         std::string eid  =  entityId.toString();
 210
 211         std::string str = NLMISC::toString("()despawnBotByAlias(\"%s\");", aliasToString(alias).c_str());
 212
 213         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 214         msgout.serial(messageVersion);
 215         msgout.serial(nbString);
 216         msgout.serial(eid);
 217         msgout.serial(str);
 218
 219         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 220 }
 221
 222 void CAiWrapperServer::setGrpHPLevel(NLMISC::CEntityId entityId, uint32 alias,  float hp)
 223 {
 224                 uint32 messageVersion = 1;
 225         uint32 nbString=2;
 226         std::string eid  =  entityId.toString();
 227
 228         std::string hpstr = NLMISC::toString("()setHPScale(%f);", hp);
 229
 230         //CMessage msgout("EVENT_NPC_GROUP_SCRIPT");
 231         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 232         msgout.serial(messageVersion);
 233         msgout.serial(nbString);
 234         msgout.serial(eid);
 235         msgout.serial(hpstr);
 236
 237         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 238 }
 239
 240 void CAiWrapperServer::setHPLevel(NLMISC::CEntityId entityId, uint32 alias, float hp)
 241 {
 242
 243         uint32 messageVersion = 1;
 244         uint32 nbString=2;
 245         std::string eid  =  entityId.toString();
 246
 247         std::string hpstr = NLMISC::toString("()setBotHPScaleByAlias(%f, \"%s\");", hp, aliasToString(alias).c_str());
 248
 249         //CMessage msgout("EVENT_NPC_GROUP_SCRIPT");
 250         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 251         msgout.serial(messageVersion);
 252         msgout.serial(nbString);
 253         msgout.serial(eid);
 254         msgout.serial(hpstr);
 255
 256         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 257 }
 258
 259
 260 void CAiWrapperServer::triggerGrpEvent(NLMISC::CEntityId entityId, float eventId)
 261 {
 262
 263         uint32 messageVersion = 1;
 264         uint32 nbString=2;
 265         std::string eid  =  entityId.toString();
 266         std::string str = NLMISC::toString("()setEvent(%f);", eventId);
 267         eventId = (float)(int) eventId;
 268         if (eventId < 0 || eventId > 10) return;
 269
 270         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 271         msgout.serial(messageVersion);
 272         msgout.serial(nbString);
 273         msgout.serial(eid);
 274         msgout.serial(str);
 275
 276         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 277
 278 }
 279
 280 void CAiWrapperServer::controlNpc(NLMISC::CEntityId clientId, NLMISC::CEntityId npc)
 281 {
 282
 283         uint32 messageVersion = 1;
 284         uint32 nbString=2;
 285         std::string eid  =  npc.toString();
 286         std::string str = NLMISC::toString("()setPlayerController(\"%s\",\"%s\");",  npc.toString().c_str(), clientId.toString().c_str());
 287
 288         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 289         msgout.serial(messageVersion);
 290         msgout.serial(nbString);
 291         msgout.serial(eid);
 292         msgout.serial(str);
 293
 294         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 295 }
 296
 297 void CAiWrapperServer::stopControlNpc(NLMISC::CEntityId clientId, NLMISC::CEntityId npc)
 298 {
 299
 300         uint32 messageVersion = 1;
 301         uint32 nbString=2;
 302         std::string eid  =  npc.toString();
 303         std::string str = NLMISC::toString("()clearPlayerController(\"%s\");", npc.toString().c_str());
 304
 305         CMessage msgout("R2_NPC_BOT_SCRIPT_BY_ID");
 306         msgout.serial(messageVersion);
 307         msgout.serial(nbString);
 308         msgout.serial(eid);
 309         msgout.serial(str);
 310
 311         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 312 }
 313
 314 void CAiWrapperServer::triggerUserTrigger(const std::string& groupName, uint32 triggerId)
 315 {
 316 /*
 317         uint32 messageVersion = 1;
 318         uint32 nbString=2;
 319
 320         std::string script = NLMISC::toString("()setEvent(%d);", triggerId);
 321
 322
 323         CMessage msgout("R2_NPC_GROUP_SCRIPT_BY_NAME");
 324         msgout.serial(messageVersion);
 325         msgout.serial(nbString);
 326         msgout.serial(const_cast<std::string&>(groupName));
 327         msgout.serial(script);
 328
 329         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 330
 331 */
 332
 333
 334
 335         {
 336                 std::string script = NLMISC::toString("\"()setEvent(%d);\"", triggerId);
 337                 CMessage msgout("EXEC_COMMAND");
 338                 std::string command = NLMISC::toString("script %s %s", groupName.c_str(), script.c_str());
 339                 msgout.serial(command);
 340                 CUnifiedNetwork::getInstance()->send("AIS",msgout);
 341         }
 342
 343 }
 344
 345 void CAiWrapperServer::setPioneerRight(NLMISC::CEntityId entityId, const R2::TPioneerRight& right)
 346 {
 347
 348         if (right == R2::TPioneerRight::DM)
 349         {
 350                 {
 351                         CMessage msgout("EXEC_COMMAND");
 352                         std::string command = NLMISC::toString("God %s %d", entityId.toString().c_str(), 1);
 353                         msgout.serial(command);
 354                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 355                 }
 356                 {
 357                         CMessage msgout("EXEC_COMMAND");
 358                         std::string command = NLMISC::toString("Invisible %s %d", entityId.toString().c_str(), 1);
 359                         msgout.serial(command);
 360                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 361                 }
 362                 {
 363                         CMessage msgout("EXEC_COMMAND");
 364                         std::string command = NLMISC::toString("Aggro %s %d", entityId.toString().c_str(), 0);
 365                         msgout.serial(command);
 366                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 367                 }
 368         }
 369         else  if (right == R2::TPioneerRight::Tester)
 370         {
 371                 {
 372                         CMessage msgout("EXEC_COMMAND");
 373                         std::string command = NLMISC::toString("God %s %d", entityId.toString().c_str(), 0);
 374                         msgout.serial(command);
 375                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 376                 }
 377                 {
 378                         CMessage msgout("EXEC_COMMAND");
 379                         std::string command = NLMISC::toString("Invisible %s %d", entityId.toString().c_str(), 0);
 380                         msgout.serial(command);
 381                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 382                 }
 383                 {
 384                         CMessage msgout("EXEC_COMMAND");
 385                         std::string command = NLMISC::toString("Aggro %s %d", entityId.toString().c_str(), 1);
 386                         msgout.serial(command);
 387                         CUnifiedNetwork::getInstance()->send("EGS",msgout);
 388                 }
 389         }
 390         else
 391         {
 392         }
 393 }
 394
 395 void CAiWrapperServer::askBotDespawnNotification(NLMISC::CEntityId creatureId, TAIAlias alias)
 396 {
 397         NLNET::CMessage msgout("ASK_BOT_DESPAWN_NOTIFICATION");
 398         uint32 messageVersion = 1;
 399         msgout.serial(messageVersion, alias, creatureId);
 400         CUnifiedNetwork::getInstance()->send("AIS",msgout);
 401 }
 402