ryzom/server/src/ai_service/state_instance.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 #include "stdpch.h"
  18 #include "state_instance.h"
  19
  20 #include "nel/misc/smart_ptr.h"
  21 #include "script_vm.h"
  22 #include "script_compiler.h"
  23 #include "event_reaction_container.h"
  24 #include "ai_grp.h"
  25 #include "ai_outpost.h"
  26
  27 using namespace std;
  28 using namespace NLMISC;
  29 using namespace AICOMP;
  30 using namespace AIVM;
  31
  32 //////////////////////////////////////////////////////////////////////////////
  33 // CStateInstance                                                           //
  34 //////////////////////////////////////////////////////////////////////////////
  35
  36 CAIState const* CStateInstance::getActiveState() const
  37 {
  38 #if !FINAL_VERSION
  39         nlassert(this!=NULL);
  40 #else
  41         if (!this)
  42                 return NULL; // ugly! -> to remove  date = 19/05/2004.
  43 #endif
  44
  45         if (_PunctualState)     // the puntual state is active !
  46                 return  _PunctualState;
  47
  48         if (_state)     // the normal state is active !
  49                 return  _state;
  50
  51         // no state is active !
  52         return  NULL;
  53 }
  54
  55 sint32 CStateInstance::getUserTimer(uint timerId)
  56 {
  57         NLMISC::clamp(timerId, 0u, 3u);
  58         return _UserTimer[timerId].timeRemaining();
  59 }
  60
  61 void CStateInstance::setUserTimer(uint timerId, sint32 time)
  62 {
  63         NLMISC::clamp(timerId, 0u, 3u);
  64         if (_UserTimer[timerId].isEnabled())
  65                 _UserTimer[timerId].set(time);
  66 }
  67
  68 void CStateInstance::addStatePersistentObj(CAIState const* keyState, CSmartPtr<NLMISC::CVirtualRefCount> anyObj)
  69 {
  70         _StatePersistentObjList.push_back(CStatePersistentObjEntry(keyState, anyObj));
  71 }
  72
  73 void CStateInstance::setFirstBotSpawned()
  74 {
  75         _FirstBotSpawned = true;
  76 }
  77
  78 struct CDiffStateRemover
  79 {
  80         CDiffStateRemover(CAIState const* const state) : _State(state) { }
  81         bool operator()(CStateInstance::CStatePersistentObjEntry const& entry) const
  82         {
  83                 return entry._State!=_State;
  84         }
  85         CAIState const* const _State;
  86 };
  87
  88 void CStateInstance::removeExceptForState(CAIState const* keyState)
  89 {
  90         TStatePersistentObjList::iterator const itLast = remove_if(_StatePersistentObjList.begin(), _StatePersistentObjList.end(), CDiffStateRemover(keyState));
  91         _StatePersistentObjList.erase(itLast, _StatePersistentObjList.end());
  92 }
  93
  94 void CStateInstance::setScriptCallBack(TStringId const& eventName, AIVM::CByteCodeEntry const& codeScriptEntry)
  95 {
  96         _CallBacks[eventName] = codeScriptEntry; // effectively affects this callback to this eventName.
  97 }
  98
  99 AIVM::CByteCodeEntry const* CStateInstance::getScriptCallBackPtr(TStringId const& eventName) const
 100 {
 101         TCallBackList::const_iterator it = _CallBacks.find(eventName);
 102         if (it==_CallBacks.end())
 103                 return NULL;
 104         return &(it->second);
 105 }
 106
 107 void CStateInstance::callScriptCallBack(IScriptContext* caller, TStringId const& funcName, int mode, std::string const& inParamsSig, std::string const& outParamsSig, AIVM::CScriptStack* stack)
 108 {
 109         // :FIXME: mode, signatures end stack are unused
 110         AIVM::CByteCodeEntry const* const codeScript = getScriptCallBackPtr(funcName);
 111         if (!codeScript || !codeScript->isValid())
 112                 return;
 113
 114         interpretCode(caller, *codeScript);     //      effectively calls the call back.
 115 }
 116
 117 void CStateInstance::callNativeCallBack(IScriptContext* caller, std::string const& funcName, int mode, std::string const& inParamsSig, std::string const& outParamsSig, AIVM::CScriptStack* stack)
 118 {
 119         // :FIXME: caller is unused
 120         CScriptNativeFuncParams* funcParam = CCompiler::getNativeFunc(funcName, inParamsSig, outParamsSig);
 121         if (funcParam!=NULL)
 122         {
 123                 bool varArg = (mode & 1)!=0; // :KLUDGE: Hardcoded 1 :TODO: Replace with a names constant (see script_compiler.cpp)
 124                 if (stack!=NULL)
 125                 {
 126                         if (varArg)
 127                         {
 128                                 stack->push(outParamsSig);
 129                                 stack->push(inParamsSig);
 130                         }
 131                         funcParam->_func(this, *stack);
 132                 }
 133                 else
 134                 {
 135                         AIVM::CScriptStack dummyStack;
 136                         if (varArg)
 137                         {
 138                                 dummyStack.push(outParamsSig);
 139                                 dummyStack.push(inParamsSig);
 140                         }
 141                         funcParam->_func(this, dummyStack);
 142                 }
 143         }
 144         else
 145         {
 146                 nlwarning("Trying to call an unknown native function '%s_%s_%s'", funcName.c_str(), inParamsSig.c_str(), outParamsSig.c_str());
 147                 // TODO:kxu: rebuild stack
 148         }
 149 }
 150
 151 void CStateInstance::dumpVarsAndFunctions(CStringWriter& sw) const
 152 {
 153         sw.append("float variables:");
 154         FOREACHC(varIt, TLogicVarList, _LogicVar)
 155                 sw.append(" "+CStringMapper::unmap(varIt->first)+" = "+NLMISC::toString(varIt->second));
 156
 157         sw.append("string variables:");
 158         FOREACHC(varIt, TStrLogicVarList, _StrLogicVar)
 159                 sw.append(" "+CStringMapper::unmap(varIt->first)+" = "+varIt->second);
 160
 161         sw.append("context variables:");
 162         FOREACHC(varIt, TCtxLogicVarList, _CtxLogicVar)
 163                 sw.append(" "+CStringMapper::unmap(varIt->first)+" = "+NLMISC::toStringPtr(varIt->second));
 164
 165         sw.append("callBacks:");
 166         FOREACHC(varIt, TCallBackList, _CallBacks)
 167                 sw.append(" "+CStringMapper::unmap(varIt->first));
 168 }
 169
 170 void CStateInstance::interpretCode(IScriptContext* caller, CByteCodeEntry const& codeScriptEntry)
 171 {
 172         AIVM::IScriptContext* parent = getPersistentStateInstance()->getParentStateInstance();
 173         AIVM::CScriptVM::getInstance()->interpretCode(this, parent, caller, codeScriptEntry);
 174 }
 175
 176 void CStateInstance::interpretCode(IScriptContext* caller, CSmartPtr<CByteCode const> const& codeScript)
 177 {
 178         interpretCode(caller, CByteCodeEntry(codeScript, 0));
 179 }
 180
 181 void CStateInstance::interpretCodeOnChildren(CByteCodeEntry const& codeScriptEntry)
 182 {
 183         vector<CSmartPtr<CGroup> > tmpList;
 184         FOREACH(childIt, CPersistentStateInstance::TChildList, getPersistentStateInstance()->childs())
 185                 tmpList.push_back((*childIt)->getGroup());
 186
 187         FOREACH(childIt, vector<CSmartPtr<CGroup> >, tmpList)
 188                 (*childIt)->getPersistentStateInstance()->interpretCode(this, codeScriptEntry);
 189 }
 190
 191 IScriptContext* CStateInstance::findContext(NLMISC::TStringId const strId)
 192 {
 193 #if !FINAL_VERSION
 194         nlassert(this->getGroup());
 195 #endif
 196         std::vector<CGroup*> grps;
 197         getGroup()->getAIInstance()->findGroup(grps, CStringMapper::unmap(strId));
 198
 199         FOREACH(grpIt, std::vector<CGroup*>, grps) {
 200                 CGroup *grp =  *grpIt;
 201                 if (grp) {
 202                         if (!grp->isSpawned())
 203                                 continue;
 204
 205                         CStateInstance  *stateInstance = grp->getPersistentStateInstance();
 206                         if (stateInstance)
 207                                 return stateInstance;
 208                 }
 209         }
 210
 211         return NULL;
 212 }
 213
 214 std::string CStateInstance::getContextName()
 215 {
 216         return getGroup()->getFullName();
 217 }
 218
 219
 220
 221 void CStateInstance::init(CAIState* startState)
 222 {
 223         _state=
 224         _PunctualState=
 225         _NextPunctualState=NULL;
 226
 227         _CancelPunctualState = false;
 228         _NextState = startState;
 229         _LogicVarChanged = false;
 230         _FirstBotSpawned = false;
 231 //      _VarIndex[CStringMapper::map("v0")]=0;
 232 //      _VarIndex[CStringMapper::map("v1")]=1;
 233 //      _VarIndex[CStringMapper::map("v2")]=2;
 234 //      _VarIndex[CStringMapper::map("v3")]=3;
 235 }
 236
 237 void CStateInstance::setGlobalNelVar(std::string const& varId, float value)
 238 {
 239         if (NLMISC::ICommand::exists(varId))
 240                 NLMISC::ICommand::execute(NLMISC::toString("%s %f", varId.c_str(), value), *NLMISC::InfoLog);
 241         else
 242                 nlwarning("Nel variable \"%s\" do not exist", varId.c_str());
 243 }
 244
 245 void CStateInstance::setGlobalNelVar(std::string const& varId, std::string value)
 246 {
 247         std::vector<std::string> args; args.push_back(value);
 248         if (NLMISC::ICommand::exists(varId))
 249                 NLMISC::ICommand::execute(NLMISC::toString("%s %s", varId.c_str(), value.c_str()), *NLMISC::InfoLog);
 250         else
 251                 nlwarning("Nel variable \"%s\" do not exist", varId.c_str());
 252 }
 253
 254
 255 void CStateInstance::blockUserEvent(uint32 eventId)
 256 {
 257         _UserEventBlocked |= (1 << eventId);
 258 }
 259
 260 void CStateInstance::unblockUserEvent(uint32 eventId)
 261 {
 262         _UserEventBlocked &= ~(1 << eventId);
 263 }
 264
 265 bool CStateInstance::isUserEventBlocked(uint32 eventId) const
 266 {
 267         return ((1 << eventId) & _UserEventBlocked) != 0;
 268 }
 269
 270 //////////////////////////////////////////////////////////////////////////////
 271 // CPersistentStateInstance                                                 //
 272 //////////////////////////////////////////////////////////////////////////////
 273
 274 void CPersistentStateInstance::updateStateInstance()
 275 {
 276         // deal with timer events -----------------------------------------
 277
 278         // Event: State Timeout
 279         if (_StateTimeout.testOnce())
 280                 processStateEvent(getEventContainer().EventPositionalStateTimeout);
 281
 282         // Event: Punctual State Timeout
 283         if (_PunctualStateTimeout.testOnce())
 284                 processStateEvent(getEventContainer().EventPunctualStateTimeout);
 285
 286         // Event: User Timer n Triggered
 287         for (uint i=0;i<4;++i)
 288         {
 289                 if      (!_UserTimer[i].testOnce())
 290                         continue;
 291                 processStateEvent(getEventContainer().EventUserTimer[i]);
 292         }
 293
 294
 295
 296         // Event logic var changed
 297         if (_LogicVarChanged)
 298         {
 299                 processStateEvent(getEventContainer().EventVariableChanged);
 300                 for(uint i =0;i<4;++i)
 301                 {
 302                         if(_LogicVarChangedList[i]==true)
 303                         {
 304                                 processStateEvent(getEventContainer().EventVariableChangedTab[i]);
 305                                 _LogicVarChangedList[i]=false;
 306                         }
 307                 }
 308                 _LogicVarChanged = false;
 309         }
 310
 311         // deal with positional state change ------------------------------
 312
 313         // if state change requested (and not in punctual state) then setup new state
 314         if      (_NextState)
 315         {
 316                 CAIState const* oldState = NULL;
 317                 if (!_PunctualState && !_NextPunctualState && _state)
 318                 {
 319                         // close down current state
 320                         oldState = _state;
 321                         processStateEvent(getEventContainer().EventEndOfState);
 322                 }
 323
 324                 // switch state & initalise state status flags
 325                 _state = _NextState;
 326                 _NextState = NULL;
 327                 _StateTimeout.disable();
 328
 329                 if (_PunctualState || _NextPunctualState)
 330                         return;
 331
 332                 removeExceptForState(_state);
 333                 processStateEvent(getEventContainer().EventStartOfState);
 334                 stateChange(oldState, _state);
 335         }
 336
 337         // deal with start of punctual state ------------------------------
 338
 339         // if state change requested then setup new state
 340         if (_NextPunctualState)
 341         {
 342                 CAIState const* oldState = NULL;
 343
 344                 breakable
 345                 {
 346                         if (_PunctualState)
 347                         {
 348                                 oldState = _PunctualState;
 349                                 break;
 350                         }
 351                         if (_state)
 352                         {
 353                                 oldState = _state;
 354                                 break;
 355                         }
 356                 }
 357
 358                 // switch state & initalize state status flags
 359                 _PunctualState = _NextPunctualState;
 360                 _NextPunctualState = NULL;
 361                 _CancelPunctualState = false;
 362                 _PunctualStateTimeout.disable();
 363
 364                 // initalize new state
 365                 CAIState const* const newState = _PunctualState;
 366
 367                 removeExceptForState(newState);
 368                 processStateEvent(getEventContainer().EventStartOfState, newState);
 369                 stateChange(oldState, newState);
 370         }
 371
 372         // must be done after start of state
 373         if (_FirstBotSpawned)
 374         {
 375                 _FirstBotSpawned = false;
 376                 processStateEvent(getEventContainer().EventFirstBotSpawned);
 377         }
 378         // deal with end of punctual state --------------------------------
 379
 380         if (!_CancelPunctualState)
 381                 return;
 382
 383         _CancelPunctualState = false;
 384
 385         // if there was an active punctual state then cancel it
 386         if (!_PunctualState)
 387                 return;
 388
 389         // switch state & initalise state status flags
 390         _PunctualStateTimeout.disable();
 391         _StateTimeout.resume(); // this line just in case timeout suspended during punctual state
 392
 393         // close down current state
 394         CAIState const* const punctualState = _PunctualState;
 395
 396         processStateEvent(getEventContainer().EventEndOfState, punctualState);
 397         _PunctualState = NULL;
 398
 399         //      this removes obj that depends on state affectation existence.
 400         removeExceptForState(_state);
 401
 402         // specialized virtual state change call.
 403         stateChange(punctualState, _state);
 404 }
 405
 406
 407
 408
 409 #include "event_reaction_include.h"