ryzom/server/src/ai_share/ai_actions.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 #include "stdpch.h"
  19
  20 #include "ai_actions.h"
  21
  22 // singleton data
  23 bool CAIActions::_init;
  24 CAIActions::IExecutor *CAIActions::_executor;
  25
  26 void CAIActions::openFile(const std::string &fileName)
  27 {
  28         nlassert(_init==true);
  29         _executor->openFile(fileName);
  30 }
  31 void CAIActions::closeFile(const std::string &fileName)
  32 {
  33         nlassert(_init==true);
  34         _executor->closeFile(fileName);
  35 }
  36
  37 void CAIActions::begin(uint32 contextAlias)
  38 {
  39         nlassert(_init==true);
  40         _executor->begin(contextAlias);
  41 }
  42
  43 void CAIActions::end(uint32 contextAlias)
  44 {
  45         nlassert(_init==true);
  46         _executor->end(contextAlias);
  47 }
  48
  49 static uint64 stringToInt64(const char *str)
  50 {
  51         uint64 id=0;
  52         uint i;
  53         for (i=0;i<8 && str[i]!=0;++i)
  54                 ((char *)&id)[i]=str[i];
  55
  56         // the following assert ensures that we never try to cram >8 letters into an int64
  57         nlassert(str[i]==0);
  58
  59         return id;
  60 }
  61
  62 using std::string;
  63
  64 inline
  65 static uint64 stringToInt64(const string &str)
  66 {
  67         return stringToInt64(str.c_str());
  68 }
  69
  70 void CAIActions::execute(const string &action,const std::vector<CAIActions::CArg> &args)
  71 {
  72         H_AUTO(CAIActions_execute);
  73         nlassert(_init==true);
  74
  75         _executor->execute(stringToInt64(action),args);
  76 }
  77
  78 void CAIActions::execute(const string &action,const std::vector<std::string> &stringArgs)
  79 {
  80         H_AUTO(CAIActions_execute);
  81         nlassert(_init==true);
  82
  83         // build an argument vector from the string vector
  84         std::vector<CAIActions::CArg> args;
  85         for (uint j=0;j<stringArgs.size();++j)
  86                 args.push_back(CAIActions::CArg(stringArgs[j]));
  87
  88         _executor->execute(stringToInt64(action),args);
  89 }
  90
  91 void CAIActions::execute(const string &action,const std::vector<int> &rawArgs)
  92 {
  93         H_AUTO(CAIActions_execute);
  94         nlassert(_init==true);
  95
  96         // build an argument vector from the string vector
  97         std::vector<CAIActions::CArg> args;
  98         for (uint j=0;j<rawArgs.size();++j)
  99                 args.push_back(CAIActions::CArg(rawArgs[j]));
 100
 101         _executor->execute(stringToInt64(action),args);
 102 }
 103
 104 void CAIActions::execute(const string &action,const std::vector<double> &rawArgs)
 105 {
 106         H_AUTO(CAIActions_execute);
 107         nlassert(_init==true);
 108
 109         // build an argument vector from the string vector
 110         std::vector<CAIActions::CArg> args;
 111         for (uint j=0;j<rawArgs.size();++j)
 112                 args.push_back(CAIActions::CArg(rawArgs[j]));
 113
 114         _executor->execute(stringToInt64(action),args);
 115 }
 116
 117 void CAIActions::execute(const string &action)
 118 {
 119         H_AUTO(CAIActions_execute);
 120         std::vector<CAIActions::CArg> emptyVector;
 121         execute(action,emptyVector);
 122 }