RigsofRods
Soft-body Physics Simulation
GameScript.cpp
Go to the documentation of this file.
1 /*
2  This source file is part of Rigs of Rods
3  Copyright 2005-2012 Pierre-Michel Ricordel
4  Copyright 2007-2012 Thomas Fischer
5  Copyright 2013-2020 Petr Ohlidal
6 
7  For more information, see http://www.rigsofrods.org/
8 
9  Rigs of Rods is free software: you can redistribute it and/or modify
10  it under the terms of the GNU General Public License version 3, as
11  published by the Free Software Foundation.
12 
13  Rigs of Rods is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
20 */
21 
22 #include "GameScript.h"
23 #include "ScriptUtils.h"
24 
25 #ifdef USE_CURL
26 # include <curl/curl.h>
27 # include <curl/easy.h>
28 #endif //USE_CURL
29 
30 // AS addons start
31 #include "scriptany/scriptany.h"
32 #include "scriptarray/scriptarray.h"
33 #include "scripthelper/scripthelper.h"
34 #include "scriptmath/scriptmath.h"
35 #include "scriptstdstring/scriptstdstring.h"
36 // AS addons end
37 
38 #include "AppContext.h"
39 #include "Actor.h"
40 #include "ActorManager.h"
41 #include "CacheSystem.h"
42 #include "Character.h"
43 #include "ChatSystem.h"
44 #include "Collisions.h"
45 #include "Console.h"
46 #include "CurlHelpers.h"
47 #include "Engine.h"
48 #include "GameContext.h"
49 #include "GfxScene.h"
50 #include "GUIManager.h"
51 #include "GUI_TopMenubar.h"
52 #include "Language.h"
53 #include "PlatformUtils.h"
54 #include "Network.h"
55 #include "RoRVersion.h"
56 #include "ScriptEngine.h"
57 #include "ScriptUtils.h"
58 #include "SkyManager.h"
59 #include "SoundScriptManager.h"
60 #include "Terrain.h"
61 #include "TerrainGeometryManager.h"
62 #include "TerrainObjectManager.h"
63 #include "Utils.h"
64 #include "VehicleAI.h"
65 #include "Water.h"
66 
67 #include <rapidjson/document.h>
68 #include <rapidjson/writer.h>
69 
70 using namespace Ogre;
71 using namespace RoR;
72 using namespace AngelScript;
73 
74 // GUIDELINE: Make functions safe from invoking in wrong circumstances,
75 // i.e. when server script calls function using SimController while in main menu.
76 // --> Getter functions should silently return zero/empty value.
77 // --> Functions performing simulation changes should log warning and do nothing.
78 
79 
80 
81 void GameScript::log(const String& msg)
82 {
83  App::GetScriptEngine()->SLOG(msg);
84 }
85 
86 void GameScript::logFormat(const char* format, ...)
87 {
88  char buffer[4000] = {};
89  sprintf(buffer, "[RoR|Script] "); // Length: 13 characters
90  char* buffer_pos = buffer + 13;
91 
92  va_list args;
93  va_start(args, format);
94  vsprintf(buffer_pos, format, args);
95  va_end(args);
96 
97  App::GetScriptEngine()->SLOG(buffer);
98 }
99 
100 void GameScript::activateAllVehicles()
101 {
103 }
104 
105 void GameScript::setTrucksForcedAwake(bool forceActive)
106 {
108 }
109 
110 float GameScript::getTime()
111 {
113 }
114 
115 void GameScript::setPersonPosition(const Vector3& vec)
116 {
117  if (!this->HavePlayerAvatar(__FUNCTION__))
118  return;
119 
121 }
122 
123 void GameScript::loadTerrain(const String& terrain)
124 {
126 }
127 
128 Vector3 GameScript::getPersonPosition()
129 {
130  Vector3 result(Vector3::ZERO);
131  if (App::GetGameContext()->GetPlayerCharacter())
133  return result;
134 }
135 
136 void GameScript::movePerson(const Vector3& vec)
137 {
138  if (!this->HavePlayerAvatar(__FUNCTION__))
139  return;
140 
142 }
143 
144 void GameScript::setPersonRotation(const Radian& rot)
145 {
146  if (!this->HavePlayerAvatar(__FUNCTION__))
147  return;
148 
150 }
151 
152 Radian GameScript::getPersonRotation()
153 {
154  Radian result(0);
155  if (App::GetGameContext()->GetPlayerCharacter())
157  return result;
158 }
159 
160 String GameScript::getCaelumTime()
161 {
162  String result = "";
163 #ifdef USE_CAELUM
164  if (App::GetGameContext()->GetTerrain())
165  {
166  result = App::GetGameContext()->GetTerrain()->getSkyManager()->GetPrettyTime();
167  }
168 #endif // USE_CAELUM
169  return result;
170 }
171 
172 void GameScript::setCaelumTime(float value)
173 {
174 #ifdef USE_CAELUM
175  if (!this->HaveSimTerrain(__FUNCTION__))
176  return;
177 
178  App::GetGameContext()->GetTerrain()->getSkyManager()->SetSkyTimeFactor(value);
179 #endif // USE_CAELUM
180 }
181 
182 bool GameScript::getCaelumAvailable()
183 {
184  bool result = false;
185 #ifdef USE_CAELUM
186  if (App::GetGameContext()->GetTerrain())
187  result = App::GetGameContext()->GetTerrain()->getSkyManager() != 0;
188 #endif // USE_CAELUM
189  return result;
190 }
191 
192 void GameScript::stopTimer()
193 {
195 }
196 
197 void GameScript::startTimer(int id)
198 {
200 }
201 
202 void GameScript::setTimeDiff(float diff)
203 {
205 }
206 
207 void GameScript::setBestLapTime(float time)
208 {
210 }
211 
212 void GameScript::setWaterHeight(float value)
213 {
214  if (!this->HaveSimTerrain(__FUNCTION__))
215  return;
216 
217  if (App::GetGameContext()->GetTerrain()->getWater())
218  {
220  water->SetStaticWaterHeight(value);
221  water->UpdateWater();
222  }
223 }
224 
225 float GameScript::getGroundHeight(Vector3& v)
226 {
227  float result = -1.0f;
228  if (App::GetGameContext()->GetTerrain())
229  result = App::GetGameContext()->GetTerrain()->GetHeightAt(v.x, v.z);
230  return result;
231 }
232 
233 float GameScript::getWaterHeight()
234 {
235  float result = 0.0f;
236  if (App::GetGameContext()->GetTerrain() && App::GetGameContext()->GetTerrain()->getWater())
238  return result;
239 }
240 
241 ActorPtr GameScript::getCurrentTruck()
242 {
244 }
245 
246 float GameScript::getGravity()
247 {
248  float result = 0.f;
249  if (App::GetGameContext()->GetTerrain())
250  {
251  result = App::GetGameContext()->GetTerrain()->getGravity();
252  }
253  return result;
254 }
255 
256 void GameScript::setGravity(float value)
257 {
258  if (!this->HaveSimTerrain(__FUNCTION__))
259  return;
260 
262 }
263 
264 ActorPtr GameScript::getTruckByNum(int num)
265 {
267 }
268 
269 int GameScript::getNumTrucksByFlag(int flag)
270 {
271  int result = 0;
272  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
273  {
274  if (!flag || static_cast<int>(actor->ar_state) == flag)
275  result++;
276  }
277  return result;
278 }
279 
280 int GameScript::getCurrentTruckNumber()
281 {
283  return (actor != nullptr) ? actor->ar_instance_id : -1;
284 }
285 
286 void GameScript::registerForEvent(int eventValue)
287 {
288  if (App::GetScriptEngine())
289  {
290  ScriptUnitID_t unit_id = App::GetScriptEngine()->getCurrentlyExecutingScriptUnit();
291  if (unit_id != SCRIPTUNITID_INVALID)
292  {
293  App::GetScriptEngine()->getScriptUnit(unit_id).eventMask |= eventValue;
294  }
295  }
296 }
297 
298 void GameScript::unRegisterEvent(int eventValue)
299 {
300  if (App::GetScriptEngine())
301  {
302  ScriptUnitID_t unit_id = App::GetScriptEngine()->getCurrentlyExecutingScriptUnit();
303  if (unit_id != SCRIPTUNITID_INVALID)
304  {
305  App::GetScriptEngine()->getScriptUnit(unit_id).eventMask &= ~eventValue;
306  }
307  }
308 }
309 
310 BitMask_t GameScript::getRegisteredEventsMask(ScriptUnitID_t nid)
311 {
312  if (App::GetScriptEngine()->scriptUnitExists(nid))
314  else
315  return BitMask_t(0);
316 }
317 
318 void GameScript::setRegisteredEventsMask(ScriptUnitID_t nid, BitMask_t eventMask)
319 {
320  if (App::GetScriptEngine()->scriptUnitExists(nid))
321  App::GetScriptEngine()->getScriptUnit(nid).eventMask = eventMask;
322 }
323 
324 void GameScript::flashMessage(String& txt, float time, float charHeight)
325 {
326  RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_SCRIPT, Console::CONSOLE_SYSTEM_NOTICE, txt, "script_code_red.png");
327 }
328 
329 void GameScript::message(String& txt, String& icon)
330 {
331  RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_SCRIPT, Console::CONSOLE_SYSTEM_NOTICE, txt, icon);
332 }
333 
334 void GameScript::updateDirectionArrow(String& text, Vector3& vec)
335 {
336  App::GetGameContext()->GetRaceSystem().UpdateDirectionArrow(const_cast<char*>(text.c_str()), Vector3(vec.x, vec.y, vec.z));
337 }
338 
339 int GameScript::getChatFontSize()
340 {
341  return 0; //NETCHAT.getFontSize();
342 }
343 
344 void GameScript::setChatFontSize(int size)
345 {
346  //NETCHAT.setFontSize(size);
347 }
348 
349 void GameScript::showChooser(const String& type, const String& instance, const String& box)
350 {
351  LoaderType ntype = LT_None;
352 
353  if (type == "airplane")
354  ntype = LT_Airplane;
355  if (type == "all")
356  ntype = LT_AllBeam;
357  if (type == "boat")
358  ntype = LT_Boat;
359  if (type == "car")
360  ntype = LT_Car;
361  if (type == "extension")
362  ntype = LT_Extension;
363  if (type == "heli")
364  ntype = LT_Airplane;
365  if (type == "load")
366  ntype = LT_Load;
367  if (type == "trailer")
368  ntype = LT_Trailer;
369  if (type == "train")
370  ntype = LT_Train;
371  if (type == "truck")
372  ntype = LT_Truck;
373  if (type == "vehicle")
374  ntype = LT_Vehicle;
375 
376  if (ntype != LT_None)
377  {
379  }
380 
381 }
382 
383 void GameScript::repairVehicle(const String& instance, const String& box, bool keepPosition)
384 {
385  App::GetGameContext()->GetActorManager()->RepairActor(App::GetGameContext()->GetTerrain()->GetCollisions(), instance, box, keepPosition);
386 }
387 
388 void GameScript::removeVehicle(const String& event_source_instance_name, const String& event_source_box_name)
389 {
390  ActorPtr actor = App::GetGameContext()->FindActorByCollisionBox(event_source_instance_name, event_source_box_name);
391  if (actor)
392  {
394  }
395 }
396 
397 AngelScript::CScriptArray* GameScript::getEditorObjects()
398 {
399  if (!this->HaveSimTerrain(__FUNCTION__))
400  return nullptr;
401 
402  if (!App::GetGameContext()->GetTerrain()->getObjectManager())
403  return nullptr;
404 
405  // Adopted from `VectorToScriptArray()` in file 'ScriptUtils.h'
406  std::string arraydecl = fmt::format("array<{}>", "TerrainEditorObjectClass@");
407  AngelScript::asITypeInfo* typeinfo = App::GetScriptEngine()->getEngine()->GetTypeInfoByDecl(arraydecl.c_str());
408  TerrainEditorObjectPtrVec& vec = App::GetGameContext()->GetTerrain()->getObjectManager()->GetEditorObjects(); AngelScript::CScriptArray* arr = AngelScript::CScriptArray::Create(typeinfo, vec.size());
409 
410  for (AngelScript::asUINT i = 0; i < arr->GetSize(); i++)
411  {
412  // Set the value of each element
413  TerrainEditorObject* ref = vec[i].GetRef();
414  arr->SetValue(i, &ref);
415  }
416 
417  return arr;
418 
419 }
420 
421 void GameScript::destroyObject(const String& instanceName)
422 {
423  if (!this->HaveSimTerrain(__FUNCTION__))
424  return;
425 
426  if (App::GetGameContext()->GetTerrain()->getObjectManager())
427  {
429  }
430 }
431 
432 void GameScript::moveObjectVisuals(const String& instanceName, const Vector3& pos)
433 {
434  if (!this->HaveSimTerrain(__FUNCTION__))
435  return;
436 
437  if (App::GetGameContext()->GetTerrain()->getObjectManager())
438  {
440  }
441 }
442 
443 void GameScript::spawnObject(const String& objectName, const String& instanceName, const Vector3& pos, const Vector3& rot, const String& eventhandler, bool uniquifyMaterials)
444 {
445  if (!this->HaveSimTerrain(__FUNCTION__))
446  return;
447 
448  if ((App::GetGameContext()->GetTerrain()->getObjectManager() == nullptr))
449  {
450  this->logFormat("spawnObject(): Cannot spawn object, no terrain loaded!");
451  return;
452  }
453 
454  if (App::GetScriptEngine()->getTerrainScriptUnit() == -1)
455  {
456  this->logFormat("spawnObject(): Cannot spawn object, no terrain script loaded!");
457  return;
458  }
459 
460  try
461  {
462  AngelScript::asIScriptModule* module = App::GetScriptEngine()->getScriptUnit(App::GetScriptEngine()->getTerrainScriptUnit()).scriptModule;
463  if (module == nullptr)
464  {
465  this->logFormat("spawnObject(): Failed to fetch/create script module");
466  return;
467  }
468 
469  int handler_func_id = -1; // no function
470  if (!eventhandler.empty())
471  {
472  // Let script author know (via Angelscript.log) there's a better alternative.
474  App::GetScriptEngine()->SLOG(
475  "spawnObject(): Specifying event handler function in `game.spawnObject()` (or .TOBJ file) is obsolete and only works with terrain scripts;"
476  " Use `eventCallbackEx()` with event `SE_EVENTBOX_ENTER` instead, it does the same job and works with any script."
477  " Just pass an empty string to the `game.spawnObject()` parameter.");
479 
480  // Look up the function and log if not found or found with bad arguments (probably a typo).
481  AngelScript::asIScriptFunction* handler_func = App::GetScriptEngine()->getFunctionByDeclAndLogCandidates(
482  App::GetScriptEngine()->getTerrainScriptUnit(), GETFUNCFLAG_REQUIRED,
484  if (handler_func != nullptr)
485  {
486  handler_func_id = handler_func->GetId();
487  }
488  }
489 
490  const String type = "";
491  App::GetGameContext()->GetTerrain()->getObjectManager()->LoadTerrainObject(objectName, pos, rot, instanceName, type, /*rendering_distance=*/0, true, handler_func_id, uniquifyMaterials);
492  }
493  catch (...)
494  {
495  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::spawnObject()");
496  return;
497  }
498 }
499 
500 void GameScript::hideDirectionArrow()
501 {
503 }
504 
505 bool GameScript::getScreenPosFromWorldPos(Ogre::Vector3 const& world_pos, Ogre::Vector2& out_screen)
506 {
507  ImVec2 screen_size = ImGui::GetIO().DisplaySize;
508  World2ScreenConverter world2screen(
509  App::GetCameraManager()->GetCamera()->getViewMatrix(true), App::GetCameraManager()->GetCamera()->getProjectionMatrix(), Ogre::Vector2(screen_size.x, screen_size.y));
510  Ogre::Vector3 pos_xyz = world2screen.Convert(world_pos);
511  if (pos_xyz.z < 0.f)
512  {
513  out_screen.x = pos_xyz.x;
514  out_screen.y = pos_xyz.y;
515  return true;
516  }
517  return false;
518 }
519 
520 Ogre::Vector2 GameScript::getDisplaySize()
521 {
522  ImVec2 size = ImGui::GetIO().DisplaySize;
523  return Vector2(size.x, size.y);
524 }
525 
526 Ogre::Vector2 GameScript::getMouseScreenPosition()
527 {
528  ImVec2 pos = ImGui::GetIO().MousePos;
529  return Vector2(pos.x, pos.y);
530 }
531 
532 int GameScript::setMaterialAmbient(const String& materialName, float red, float green, float blue)
533 {
534  try
535  {
536  MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
537  if (m.isNull())
538  return 0;
539  m->setAmbient(red, green, blue);
540  }
541  catch (...)
542  {
543  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialAmbient()");
544  return 0;
545  }
546  return 1;
547 }
548 
549 int GameScript::setMaterialDiffuse(const String& materialName, float red, float green, float blue, float alpha)
550 {
551  try
552  {
553  MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
554  if (m.isNull())
555  return 0;
556  m->setDiffuse(red, green, blue, alpha);
557  }
558  catch (...)
559  {
560  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialDiffuse()");
561  return 0;
562  }
563  return 1;
564 }
565 
566 int GameScript::setMaterialSpecular(const String& materialName, float red, float green, float blue, float alpha)
567 {
568  try
569  {
570  MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
571  if (m.isNull())
572  return 0;
573  m->setSpecular(red, green, blue, alpha);
574  }
575  catch (...)
576  {
577  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialSpecular()");
578  return 0;
579  }
580  return 1;
581 }
582 
583 int GameScript::setMaterialEmissive(const String& materialName, float red, float green, float blue)
584 {
585  try
586  {
587  MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
588  if (m.isNull())
589  return 0;
590  m->setSelfIllumination(red, green, blue);
591  }
592  catch (...)
593  {
594  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialEmissive()");
595  return 0;
596  }
597  return 1;
598 }
599 
600 int GameScript::getTextureUnitState(TextureUnitState** tu, const String materialName, int techniqueNum, int passNum, int textureUnitNum)
601 {
602  // Internal helper - propagate exceptions outside so that correct function names appear in exception-events
603  // ========================================================================================================
604 
605  MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
606  if (m.isNull())
607  return 1;
608 
609  // verify technique
610  if (techniqueNum < 0 || techniqueNum > m->getNumTechniques())
611  return 2;
612  Technique* t = m->getTechnique(techniqueNum);
613  if (!t)
614  return 2;
615 
616  //verify pass
617  if (passNum < 0 || passNum > t->getNumPasses())
618  return 3;
619  Pass* p = t->getPass(passNum);
620  if (!p)
621  return 3;
622 
623  //verify texture unit
624  if (textureUnitNum < 0 || textureUnitNum > p->getNumTextureUnitStates())
625  return 4;
626  TextureUnitState* tut = p->getTextureUnitState(textureUnitNum);
627  if (!tut)
628  return 4;
629 
630  *tu = tut;
631  return 0;
632 }
633 
634 int GameScript::setMaterialTextureName(const String& materialName, int techniqueNum, int passNum, int textureUnitNum, const String& textureName)
635 {
636  try
637  {
638  TextureUnitState* tu = 0;
639  int res = getTextureUnitState(&tu, materialName, techniqueNum, passNum, textureUnitNum);
640  if (res == 0 && tu != 0)
641  {
642  // finally, set it
643  tu->setTextureName(textureName);
644  }
645  return res;
646  }
647  catch (...)
648  {
649  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialTextureName()");
650  return 0;
651  }
652 }
653 
654 int GameScript::setMaterialTextureRotate(const String& materialName, int techniqueNum, int passNum, int textureUnitNum, float rotation)
655 {
656  try
657  {
658  TextureUnitState* tu = 0;
659  int res = getTextureUnitState(&tu, materialName, techniqueNum, passNum, textureUnitNum);
660  if (res == 0 && tu != 0)
661  {
662  tu->setTextureRotate(Degree(rotation));
663  }
664  return res;
665  }
666  catch (...)
667  {
668  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialTextureRotate()");
669  return 0;
670  }
671 }
672 
673 int GameScript::setMaterialTextureScroll(const String& materialName, int techniqueNum, int passNum, int textureUnitNum, float sx, float sy)
674 {
675  try
676  {
677  TextureUnitState* tu = 0;
678  int res = getTextureUnitState(&tu, materialName, techniqueNum, passNum, textureUnitNum);
679  if (res == 0 && tu != 0)
680  {
681  tu->setTextureScroll(sx, sy);
682  }
683  return res;
684  }
685  catch (...)
686  {
687  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialTextureScroll()");
688  return 0;
689  }
690 }
691 
692 int GameScript::setMaterialTextureScale(const String& materialName, int techniqueNum, int passNum, int textureUnitNum, float u, float v)
693 {
694  try
695  {
696  TextureUnitState* tu = 0;
697  int res = getTextureUnitState(&tu, materialName, techniqueNum, passNum, textureUnitNum);
698  if (res == 0 && tu != 0)
699  {
700  tu->setTextureScale(u, v);
701  }
702  return res;
703  }
704  catch (...)
705  {
706  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialTextureScale()");
707  return 0;
708  }
709 }
710 
711 float GameScript::rangeRandom(float from, float to)
712 {
713  return Math::RangeRandom(from, to);
714 }
715 
716 int GameScript::getLoadedTerrain(String& result)
717 {
718  String terrainName = "";
719 
720  if (App::GetGameContext()->GetTerrain())
721  {
722  terrainName = App::GetGameContext()->GetTerrain()->getTerrainName();
723  result = terrainName;
724  }
725 
726  return !terrainName.empty();
727 }
728 
729 RoR::TerrainPtr GameScript::getTerrain()
730 {
731  return App::GetGameContext()->GetTerrain();
732 }
733 
734 void GameScript::clearEventCache()
735 {
736  if (!this->HaveSimTerrain(__FUNCTION__))
737  return;
738 
739  if (App::GetGameContext()->GetTerrain()->GetCollisions() == nullptr)
740  {
741  this->logFormat("Cannot execute '%s', collisions not ready", __FUNCTION__);
742  return;
743  }
744 
746 }
747 
748 void GameScript::setCameraPosition(const Vector3& pos)
749 {
750  if (!this->HaveMainCamera(__FUNCTION__))
751  return;
752 
753  App::GetCameraManager()->GetCameraNode()->setPosition(Vector3(pos.x, pos.y, pos.z));
754 }
755 
756 void GameScript::setCameraDirection(const Vector3& rot)
757 {
758  if (!this->HaveMainCamera(__FUNCTION__))
759  return;
760 
761  App::GetCameraManager()->GetCameraNode()->setDirection(Vector3(rot.x, rot.y, rot.z), Ogre::Node::TS_WORLD);
762 }
763 
764 void GameScript::setCameraOrientation(const Quaternion& q)
765 {
766  if (!this->HaveMainCamera(__FUNCTION__))
767  return;
768 
769  App::GetCameraManager()->GetCameraNode()->setOrientation(Quaternion(q.w, q.x, q.y, q.z));
770 }
771 
772 void GameScript::setCameraYaw(float rotX)
773 {
774  if (!this->HaveMainCamera(__FUNCTION__))
775  return;
776 
777  App::GetCameraManager()->GetCameraNode()->yaw(Degree(rotX), Ogre::Node::TS_WORLD);
778 }
779 
780 void GameScript::setCameraPitch(float rotY)
781 {
782  if (!this->HaveMainCamera(__FUNCTION__))
783  return;
784 
785  App::GetCameraManager()->GetCameraNode()->pitch(Degree(rotY));
786 }
787 
788 void GameScript::setCameraRoll(float rotZ)
789 {
790  if (!this->HaveMainCamera(__FUNCTION__))
791  return;
792 
793  App::GetCameraManager()->GetCameraNode()->roll(Degree(rotZ));
794 }
795 
796 Vector3 GameScript::getCameraPosition()
797 {
798  Vector3 result(Vector3::ZERO);
799  if (App::GetCameraManager()->GetCameraNode())
800  result = App::GetCameraManager()->GetCameraNode()->getPosition();
801  return result;
802 }
803 
804 Vector3 GameScript::getCameraDirection()
805 {
806  Vector3 result(Vector3::ZERO);
807  if (App::GetCameraManager()->GetCameraNode())
808  {
809  // Direction points down -Z by default (adapted from Ogre::Camera)
810  result = App::GetCameraManager()->GetCameraNode()->getOrientation() * -Ogre::Vector3::UNIT_Z;
811  }
812  return result;
813 }
814 
815 Quaternion GameScript::getCameraOrientation()
816 {
817  Quaternion result(Quaternion::ZERO);
818  if (App::GetCameraManager()->GetCameraNode())
819  result = App::GetCameraManager()->GetCameraNode()->getOrientation();
820  return result;
821 }
822 
823 void GameScript::cameraLookAt(const Vector3& pos)
824 {
825  if (!this->HaveMainCamera(__FUNCTION__))
826  return;
827 
828  App::GetCameraManager()->GetCameraNode()->lookAt(Vector3(pos.x, pos.y, pos.z), Ogre::Node::TS_WORLD);
829 }
830 
831 int GameScript::useOnlineAPI(const String& apiquery, const AngelScript::CScriptDictionary& dict, String& result)
832 {
833  if (App::app_disable_online_api->getBool())
834  return 0;
835 
836  ScriptUnitID_t unit_id = App::GetScriptEngine()->getCurrentlyExecutingScriptUnit();
837  if (unit_id == SCRIPTUNITID_INVALID)
838  return 2;
839 
840  ActorPtr player_actor = App::GetGameContext()->GetPlayerActor();
841 
842  if (player_actor == nullptr)
843  return 1;
844 
845  std::string hashtok = Sha1Hash(App::mp_player_name->getStr());
846  std::string url = App::mp_api_url->getStr() + apiquery;
847  std::string user = std::string("RoR-Api-User: ") + App::mp_player_name->getStr();
848  std::string token = std::string("RoR-Api-User-Token: ") + hashtok;
849 
850  std::string terrain_name = App::GetGameContext()->GetTerrain()->getTerrainName();
851 
852  std::string script_name = App::GetScriptEngine()->getScriptUnit(unit_id).scriptName;
853  std::string script_hash = App::GetScriptEngine()->getScriptUnit(unit_id).scriptHash;
854 
855  rapidjson::Document j_doc;
856  j_doc.SetObject();
857 
858  j_doc.AddMember("user-name", rapidjson::StringRef(App::mp_player_name->getStr().c_str()), j_doc.GetAllocator());
859  j_doc.AddMember("user-country", rapidjson::StringRef(App::app_country->getStr().c_str()), j_doc.GetAllocator());
860  j_doc.AddMember("user-token", rapidjson::StringRef(hashtok.c_str()), j_doc.GetAllocator());
861 
862  j_doc.AddMember("terrain-name", rapidjson::StringRef(terrain_name.c_str()), j_doc.GetAllocator());
863  j_doc.AddMember("terrain-filename", rapidjson::StringRef(App::sim_terrain_name->getStr().c_str()), j_doc.GetAllocator());
864 
865  j_doc.AddMember("script-name", rapidjson::StringRef(script_name.c_str()), j_doc.GetAllocator());
866  j_doc.AddMember("script-hash", rapidjson::StringRef(script_hash.c_str()), j_doc.GetAllocator());
867 
868  j_doc.AddMember("actor-name", rapidjson::StringRef(player_actor->ar_design_name.c_str()), j_doc.GetAllocator());
869  j_doc.AddMember("actor-filename", rapidjson::StringRef(player_actor->ar_filename.c_str()), j_doc.GetAllocator());
870  j_doc.AddMember("actor-hash", rapidjson::StringRef(player_actor->ar_filehash.c_str()), j_doc.GetAllocator());
871 
872  rapidjson::Value j_linked_actors(rapidjson::kArrayType);
873  for (ActorPtr& actor : player_actor->ar_linked_actors)
874  {
875  rapidjson::Value j_actor(rapidjson::kObjectType);
876  j_actor.AddMember("actor-name", rapidjson::StringRef(actor->ar_design_name.c_str()), j_doc.GetAllocator());
877  j_actor.AddMember("actor-filename", rapidjson::StringRef(actor->ar_filename.c_str()), j_doc.GetAllocator());
878  j_actor.AddMember("actor-hash", rapidjson::StringRef(actor->ar_filehash.c_str()), j_doc.GetAllocator());
879  j_linked_actors.PushBack(j_actor, j_doc.GetAllocator());
880  }
881  j_doc.AddMember("linked-actors", j_linked_actors, j_doc.GetAllocator());
882 
883  j_doc.AddMember("avg-fps", getAvgFPS(), j_doc.GetAllocator());
884  j_doc.AddMember("ror-version", rapidjson::StringRef(ROR_VERSION_STRING), j_doc.GetAllocator());
885 
886  for (auto item : dict)
887  {
888  const std::string& key = item.GetKey();
889  const std::string* value = (std::string *)item.GetAddressOfValue();
890  j_doc.AddMember(rapidjson::StringRef(key.c_str()), rapidjson::StringRef(value->c_str()), j_doc.GetAllocator());
891  }
892 
893  rapidjson::StringBuffer buffer;
894  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
895  j_doc.Accept(writer);
896  std::string json = buffer.GetString();
897 
898 #if USE_CURL
899  RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
900  _L("using Online API..."), "information.png");
901 
902  LOG("[RoR|GameScript] Submitting race results to '" + url + "'");
903 
904  std::thread([url, user, token, json]()
905  {
906  long response_code = 0;
907 
908  struct curl_slist *slist = NULL;
909  slist = curl_slist_append(slist, "Accept: application/json");
910  slist = curl_slist_append(slist, "Content-Type: application/json");
911  slist = curl_slist_append(slist, user.c_str());
912  slist = curl_slist_append(slist, token.c_str());
913 
914  CURL *curl = curl_easy_init();
915  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
916  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
917  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json.c_str());
918 
919  CURLcode curl_result = curl_easy_perform(curl);
920  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
921 
922  if (curl_result != CURLE_OK || response_code != 200)
923  {
924  Ogre::LogManager::getSingleton().stream()
925  << "[RoR|GameScript] `useOnlineAPI()` failed to submit data;"
926  << " Error: '" << curl_easy_strerror(curl_result) << "'; HTTP status code: " << response_code;
927  }
928 
929  curl_easy_cleanup(curl);
930  curl = nullptr;
931  curl_slist_free_all(slist);
932  slist = NULL;
933  }).detach();
934 #else // USE_CURL
935  RoR::App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_WARNING,
936  _L("Cannot use Online API in this build (CURL not available)"));
937 #endif // USE_CURL
938 
939  return 0;
940 }
941 
942 void GameScript::openUrlInDefaultBrowser(const std::string& url)
943 {
944  RoR::OpenUrlInDefaultBrowser(url); // PlatformUtils.h
945 }
946 
947 void GameScript::fetchUrlAsStringAsync(const std::string& url, const std::string& display_filename)
948 {
949 #if defined(USE_CURL)
950  CurlTaskContext task;
951  task.ctc_url = url;
952  task.ctc_displayname = display_filename;
953  // Messages to post // See `RoR::angelScriptThreadStatus`
954  task.ctc_msg_progress = MSG_APP_SCRIPT_THREAD_STATUS; // `RoR::ASTHREADSTATUS_CURLSTRING_PROGRESS`
955  task.ctc_msg_success = MSG_APP_SCRIPT_THREAD_STATUS; // `RoR::ASTHREADSTATUS_CURLSTRING_SUCCESS`
956  task.ctc_msg_failure = MSG_APP_SCRIPT_THREAD_STATUS; // `RoR::ASTHREADSTATUS_CURLSTRING_FAILURE`
957 
958  std::packaged_task<void(CurlTaskContext)> pktask(GetUrlAsStringMQ);
959  std::thread(std::move(pktask), task).detach();
960 #endif // defined(USE_CURL)
961 }
962 
963 void GameScript::boostCurrentTruck(float factor)
964 {
966  if (actor && actor->ar_engine)
967  {
968  float rpm = actor->ar_engine->getRPM();
969  rpm += 2000.0f * factor;
970  actor->ar_engine->setRPM(rpm);
971  }
972 }
973 
974 int GameScript::addScriptFunction(const String& arg, ScriptUnitID_t nid)
975 {
976  return App::GetScriptEngine()->addFunction(arg, nid);
977 }
978 
979 int GameScript::scriptFunctionExists(const String& arg, ScriptUnitID_t nid)
980 {
981  return App::GetScriptEngine()->functionExists(arg, nid);
982 }
983 
984 int GameScript::deleteScriptFunction(const String& arg, ScriptUnitID_t nid)
985 {
986  return App::GetScriptEngine()->deleteFunction(arg, nid);
987 }
988 
989 int GameScript::addScriptVariable(const String& arg, ScriptUnitID_t nid)
990 {
991  return App::GetScriptEngine()->addVariable(arg, nid);
992 }
993 
994 int GameScript::scriptVariableExists(const String& arg, ScriptUnitID_t nid)
995 {
996  return App::GetScriptEngine()->variableExists(arg, nid);
997 }
998 
999 int GameScript::deleteScriptVariable(const String& arg, ScriptUnitID_t nid)
1000 {
1001  return App::GetScriptEngine()->deleteVariable(arg, nid);
1002 }
1003 
1004 int GameScript::getScriptVariable(const Ogre::String& varName, void *ref, int refTypeId, ScriptUnitID_t nid)
1005 {
1006  return App::GetScriptEngine()->getVariable(varName, ref, refTypeId, nid);
1007 }
1008 
1009 int GameScript::sendGameCmd(const String& message)
1010 {
1011 #ifdef USE_SOCKETW
1012  if (RoR::App::mp_state->getEnum<MpState>() == RoR::MpState::CONNECTED)
1013  {
1014  App::GetNetwork()->AddPacket(0, RoRnet::MSG2_GAME_CMD, (int)message.size(), const_cast<char*>(message.c_str()));
1015  return 0;
1016  }
1017 #endif // USE_SOCKETW
1018 
1019  return -11;
1020 }
1021 
1022 AngelScript::CScriptArray* GameScript::getRunningScripts()
1023 {
1024  std::vector<ScriptUnitID_t> ids;
1025  for (auto& pair: App::GetScriptEngine()->getScriptUnits())
1026  ids.push_back(pair.first);
1027 
1028  return VectorToScriptArray(ids, "int");
1029 }
1030 
1031 
1032 AngelScript::CScriptDictionary* GameScript::getScriptDetails(ScriptUnitID_t nid)
1033 {
1034  if (!App::GetScriptEngine()->scriptUnitExists(nid))
1035  return nullptr;
1036 
1038  AngelScript::CScriptDictionary* dict = AngelScript::CScriptDictionary::Create(App::GetScriptEngine()->getEngine());
1039  int stringTypeid = App::GetScriptEngine()->getEngine()->GetTypeIdByDecl("string");
1040  int scriptCategoryTypeid = App::GetScriptEngine()->getEngine()->GetTypeIdByDecl("ScriptCategory");
1041 
1042  dict->Set("uniqueId", (asINT64)info.uniqueId);
1043  dict->Set("scriptName", new std::string(info.scriptName), stringTypeid);
1044  dict->Set("scriptCategory", &info.scriptCategory, scriptCategoryTypeid);
1045  dict->Set("eventMask", (asINT64)info.eventMask);
1046  dict->Set("scriptBuffer", new std::string(info.scriptBuffer), stringTypeid);
1047 
1048  // TBD Some other time...
1049  //AngelScript::asIScriptModule* scriptModule = nullptr;
1050  //AngelScript::asIScriptFunction* frameStepFunctionPtr = nullptr; //!< script function pointer to the frameStep function
1051  //AngelScript::asIScriptFunction* eventCallbackFunctionPtr = nullptr; //!< script function pointer to the event callback function
1052  //AngelScript::asIScriptFunction* eventCallbackExFunctionPtr = nullptr; //!< script function pointer to the event callback function
1053  //AngelScript::asIScriptFunction* defaultEventCallbackFunctionPtr = nullptr; //!< script function pointer for spawner events
1054  //ActorPtr associatedActor; //!< For ScriptCategory::ACTOR
1055  //Ogre::String scriptHash;
1056 
1057  return dict;
1058 }
1059 
1060 VehicleAIPtr GameScript::getCurrentTruckAI()
1061 {
1062  VehicleAIPtr result = nullptr;
1063  if (App::GetGameContext()->GetPlayerActor())
1064  {
1066  }
1067  return result;
1068 }
1069 
1070 VehicleAIPtr GameScript::getTruckAIByNum(int num)
1071 {
1072  VehicleAIPtr result = nullptr;
1074  if (actor != nullptr)
1075  {
1076  result = actor->ar_vehicle_ai;
1077  }
1078  return result;
1079 }
1080 
1081 ActorPtr GameScript::spawnTruck(Ogre::String& truckName, Ogre::Vector3& pos, Ogre::Vector3& rot)
1082 {
1083  ActorSpawnRequest rq;
1084  rq.asr_position = pos;
1085  rq.asr_rotation = Quaternion(Degree(rot.x), Vector3::UNIT_X) * Quaternion(Degree(rot.y), Vector3::UNIT_Y) * Quaternion(Degree(rot.z), Vector3::UNIT_Z);
1086  rq.asr_filename = truckName;
1087  return App::GetGameContext()->SpawnActor(rq);
1088 }
1089 
1090 ActorPtr GameScript::spawnTruckAI(Ogre::String& truckName, Ogre::Vector3& pos, Ogre::String& truckSectionConfig, std::string& truckSkin, int x)
1091 {
1092  try
1093  {
1094  ActorSpawnRequest rq;
1095  rq.asr_position = pos;
1096 
1097  // Set rotation based on first two waypoints
1098  std::vector<Ogre::Vector3> waypoints;
1099  for (int i = 0; i < App::GetGuiManager()->TopMenubar.ai_waypoints.size(); i++)
1100  {
1101  waypoints.push_back(App::GetGuiManager()->TopMenubar.ai_waypoints[i].position);
1102  }
1103  if (App::GetGuiManager()->TopMenubar.ai_mode == 3 && x == 1) // Crash driving mode
1104  {
1105  std::reverse(waypoints.begin(), waypoints.end());
1106  }
1107 
1108  // Check if we have enough waypoints
1109  Ogre::Vector3 dir = Ogre::Vector3::ZERO;
1110  if (waypoints.size() >= 2)
1111  dir = waypoints[0] - waypoints[1];
1112  else if (waypoints.size() >= 1)
1113  dir = waypoints[0];
1114  dir.y = 0;
1115  rq.asr_rotation = Ogre::Vector3::UNIT_X.getRotationTo(dir, Ogre::Vector3::UNIT_Y);
1116 
1117  rq.asr_filename = truckName;
1118  rq.asr_config = truckSectionConfig;
1121  return App::GetGameContext()->SpawnActor(rq);
1122  }
1123  catch (...)
1124  {
1125  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::setMaterialTextureScale()");
1126  return ActorPtr();
1127  }
1128 }
1129 
1130 AngelScript::CScriptArray* GameScript::getWaypoints(int x)
1131 {
1132  std::vector<Ogre::Vector3> vec;
1133  for (int i = 0; i < App::GetGuiManager()->TopMenubar.ai_waypoints.size(); i++)
1134  {
1135  vec.push_back(App::GetGuiManager()->TopMenubar.ai_waypoints[i].position);
1136  }
1137  if (App::GetGuiManager()->TopMenubar.ai_mode == 3 && x == 1) // Crash driving mode
1138  {
1139  std::reverse(vec.begin(), vec.end());
1140  }
1141 
1142  AngelScript::CScriptArray* arr = AngelScript::CScriptArray::Create(AngelScript::asGetActiveContext()->GetEngine()->GetTypeInfoByDecl("array<vector3>"), vec.size());
1143 
1144  for(AngelScript::asUINT i = 0; i < arr->GetSize(); i++)
1145  {
1146  // Set the value of each element
1147  arr->SetValue(i, &vec[i]);
1148  }
1149 
1150  return arr;
1151 }
1152 
1153 AngelScript::CScriptArray* GameScript::getAllTrucks()
1154 {
1156  AngelScript::CScriptArray* arr = AngelScript::CScriptArray::Create(AngelScript::asGetActiveContext()->GetEngine()->GetTypeInfoByDecl("array<BeamClass@>"), actors.size());
1157 
1158  for (AngelScript::asUINT i = 0; i < arr->GetSize(); i++)
1159  {
1160  // Set the value of each element
1161  arr->SetValue(i, &actors[i]);
1162  }
1163 
1164  return arr;
1165 }
1166 
1167 void GameScript::addWaypoint(const Ogre::Vector3& pos)
1168 {
1169  std::vector<Ogre::Vector3> waypoints;
1170  for (int i = 0; i < App::GetGuiManager()->TopMenubar.ai_waypoints.size(); i++)
1171  {
1172  waypoints.push_back(App::GetGuiManager()->TopMenubar.ai_waypoints[i].position);
1173  }
1174 }
1175 
1176 AngelScript::CScriptArray* GameScript::getWaypointsSpeed()
1177 {
1178  std::vector<int> vec;
1179  for (int i = 0; i < App::GetGuiManager()->TopMenubar.ai_waypoints.size(); i++)
1180  {
1181  vec.push_back(App::GetGuiManager()->TopMenubar.ai_waypoints[i].speed);
1182  }
1183 
1184  AngelScript::CScriptArray* arr = AngelScript::CScriptArray::Create(AngelScript::asGetActiveContext()->GetEngine()->GetTypeInfoByDecl("array<int>"), vec.size());
1185 
1186  for(AngelScript::asUINT i = 0; i < arr->GetSize(); i++)
1187  {
1188  // Set the value of each element
1189  arr->SetValue(i, &vec[i]);
1190  }
1191 
1192  return arr;
1193 }
1194 
1195 int GameScript::getAIVehicleCount()
1196 {
1197  int num = App::GetGuiManager()->TopMenubar.ai_num;
1198  return num;
1199 }
1200 
1201 int GameScript::getAIVehicleDistance()
1202 {
1204  return dist;
1205 }
1206 
1207 int GameScript::getAIVehiclePositionScheme()
1208 {
1210  return scheme;
1211 }
1212 
1213 int GameScript::getAIVehicleSpeed()
1214 {
1215  int speed = App::GetGuiManager()->TopMenubar.ai_speed;
1216  return speed;
1217 }
1218 
1219 Ogre::String GameScript::getAIVehicleName(int x)
1220 {
1221  if ((App::GetGuiManager()->TopMenubar.ai_mode == 2 || App::GetGuiManager()->TopMenubar.ai_mode == 3) && x == 1) // Drag Race or Crash driving mode
1222  {
1223  Ogre::String name = App::GetGuiManager()->TopMenubar.ai_fname2;
1224  return name;
1225  }
1226  else
1227  {
1228  Ogre::String name = App::GetGuiManager()->TopMenubar.ai_fname;
1229  return name;
1230  }
1231 }
1232 
1233 Ogre::String GameScript::getAIVehicleSectionConfig(int x)
1234 {
1235  if ((App::GetGuiManager()->TopMenubar.ai_mode == 2 || App::GetGuiManager()->TopMenubar.ai_mode == 3) && x == 1) // Drag Race or Crash driving mode
1236  {
1237  Ogre::String config = App::GetGuiManager()->TopMenubar.ai_sectionconfig2;
1238  return config;
1239  }
1240  else
1241  {
1242  Ogre::String config = App::GetGuiManager()->TopMenubar.ai_sectionconfig;
1243  return config;
1244  }
1245 }
1246 
1247 std::string GameScript::getAIVehicleSkin(int x)
1248 {
1249  if ((App::GetGuiManager()->TopMenubar.ai_mode == 2 || App::GetGuiManager()->TopMenubar.ai_mode == 3) && x == 1) // Drag Race or Crash driving mode
1250  {
1251  std::string skin = App::GetGuiManager()->TopMenubar.ai_skin2;
1252  return skin;
1253  }
1254  else
1255  {
1256  std::string skin = App::GetGuiManager()->TopMenubar.ai_skin;
1257  return skin;
1258  }
1259 }
1260 
1261 int GameScript::getAIRepeatTimes()
1262 {
1263  int times = App::GetGuiManager()->TopMenubar.ai_times;
1264  return times;
1265 }
1266 
1267 int GameScript::getAIMode()
1268 {
1269  int mode = App::GetGuiManager()->TopMenubar.ai_mode;
1270  return mode;
1271 }
1272 
1273 // AI: set
1274 
1275 void GameScript::setAIVehicleCount(int num)
1276 {
1278 }
1279 
1280 void GameScript::setAIVehicleDistance(int dist)
1281 {
1283 }
1284 
1285 void GameScript::setAIVehiclePositionScheme(int scheme)
1286 {
1288 }
1289 
1290 void GameScript::setAIVehicleSpeed(int speed)
1291 {
1293 }
1294 
1295 void GameScript::setAIVehicleName(int x, std::string name)
1296 {
1297  if ((App::GetGuiManager()->TopMenubar.ai_mode == 2 || App::GetGuiManager()->TopMenubar.ai_mode == 3) && x == 1) // Drag Race or Crash driving mode
1298  {
1300  }
1301  else
1302  {
1304  }
1305 }
1306 
1307 void GameScript::setAIVehicleSectionConfig(int x, std::string config)
1308 {
1309  switch (x)
1310  {
1311  case 0:
1313  break;
1314  case 1:
1316  break;
1317  default:
1318  this->log(fmt::format("setAIVehicleSectionConfig: ERROR, valid 'x' is 0 or 1, got {}", x));
1319  break;
1320  }
1321 }
1322 
1323 void GameScript::setAIVehicleSkin(int x, std::string skin)
1324 {
1325  switch (x)
1326  {
1327  case 0:
1329  break;
1330  case 1:
1332  break;
1333  default:
1334  this->log(fmt::format("setAIVehicleSkin: ERROR, valid 'x' is 0 or 1, got {}", x));
1335  break;
1336  }
1337 }
1338 
1339 void GameScript::setAIRepeatTimes(int times)
1340 {
1342 }
1343 
1344 void GameScript::setAIMode(int mode)
1345 {
1347 }
1348 
1349 void GameScript::showMessageBox(Ogre::String& title, Ogre::String& text, bool use_btn1, Ogre::String& btn1_text, bool allow_close, bool use_btn2, Ogre::String& btn2_text)
1350 {
1351  // Sanitize inputs
1352  const char* btn1_cstr = nullptr; // = Button disabled
1353  const char* btn2_cstr = nullptr;
1354 
1355  if (use_btn1)
1356  {
1357  btn1_cstr = (btn1_text.empty() ? "~1~" : btn1_text.c_str());
1358  }
1359  if (use_btn2)
1360  {
1361  btn2_cstr = (btn2_text.empty() ? "~2~" : btn2_text.c_str());
1362  }
1363 
1364  RoR::App::GetGuiManager()->ShowMessageBox(title.c_str(), text.c_str(), allow_close, btn1_cstr, btn2_cstr);
1365 }
1366 
1367 void GameScript::backToMenu()
1368 {
1371 }
1372 
1373 void GameScript::quitGame()
1374 {
1376 }
1377 
1378 float GameScript::getFPS()
1379 {
1380  return App::GetAppContext()->GetRenderWindow()->getStatistics().lastFPS;
1381 }
1382 
1383 float GameScript::getAvgFPS()
1384 {
1385  return App::GetAppContext()->GetRenderWindow()->getStatistics().avgFPS;
1386 }
1387 
1388 bool GameScript::getMousePositionOnTerrain(Ogre::Vector3& out_pos)
1389 {
1390  if (!HaveSimTerrain(__FUNCTION__))
1391  return false;
1392 
1393  Ogre::Vector2 mouse_npos = App::GetInputEngine()->getMouseNormalizedScreenPos();
1394  Ogre::Ray ray = App::GetCameraManager()->GetCamera()->getCameraToViewportRay(mouse_npos.x, mouse_npos.y);
1395  Ogre::TerrainGroup::RayResult ray_result = App::GetGameContext()->GetTerrain()->getGeometryManager()->getTerrainGroup()->rayIntersects(ray);
1396  if (ray_result.hit)
1397  {
1398  out_pos = ray_result.position;
1399  }
1400  return ray_result.hit;
1401 }
1402 
1403 class ScriptRayQueryListener : public Ogre::RaySceneQueryListener
1404 {
1405 public:
1406  Ogre::Ray ray;
1407  std::vector<Ogre::MovableObject*> results_array;
1408 
1409  bool queryResult(MovableObject* obj, Real distance) override
1410  {
1411  results_array.push_back(obj);
1412  return true; // Continue query
1413  }
1414 
1415  bool queryResult(SceneQuery::WorldFragment* fragment, Real distance) override
1416  {
1417  return true; // Continue query
1418  }
1419 };
1420 
1421 CScriptArray* GameScript::getMousePointedMovableObjects()
1422 {
1423  if (!HaveSimTerrain(__FUNCTION__))
1424  return nullptr;
1425 
1426  Ogre::Vector2 mouse_npos = App::GetInputEngine()->getMouseNormalizedScreenPos();
1427  Ogre::Ray ray = App::GetCameraManager()->GetCamera()->getCameraToViewportRay(mouse_npos.x, mouse_npos.y);
1428  Ogre::DefaultRaySceneQuery query(App::GetGfxScene()->GetSceneManager());
1429  query.setRay(ray);
1430  query.setSortByDistance(true);
1432  qlis.ray = ray;
1433  query.execute(&qlis);
1434  return VectorToScriptArray(qlis.results_array, "Ogre::MovableObject@");
1435 }
1436 
1437 Ogre::SceneManager* GameScript::getSceneManager()
1438 {
1439  return App::GetGfxScene()->GetSceneManager();
1440 }
1441 
1442 bool GameScript::pushMessage(MsgType type, AngelScript::CScriptDictionary* dict)
1443 {
1444  Message m(type);
1445  std::string log_msg = fmt::format("`pushMessage({})`", MsgTypeToString(type));
1446 
1447  switch (type)
1448  {
1449  // -- NOT ALLOWED --
1450 
1451  // Application
1453  // Networking
1458  case MSG_NET_SERVER_KICK:
1460  case MSG_NET_RECV_ERROR:
1468  // GUI
1473  // Editing
1475  this->log(fmt::format("{} is not allowed.", log_msg));
1476  return false;
1477 
1478 
1479  // -- SOME ASSEMBLY REQUIRED --
1480 
1481  // Application
1483  {
1485  bool has_filename = GetValueFromScriptDict(log_msg, dict, /*required:*/false, "filename", "string", rq->lsr_filename);
1486  bool has_buffer = GetValueFromScriptDict(log_msg, dict, /*required:*/false, "buffer", "string", rq->lsr_buffer);
1487  if (!has_filename && !has_buffer)
1488  {
1489  this->log(fmt::format("{}: ERROR, either 'filename' or 'buffer' must be set!", log_msg));
1490  delete rq;
1491  return false;
1492  }
1493  GetValueFromScriptDict(log_msg, dict, /*required:*/false, "category", "ScriptCategory", rq->lsr_category);
1494  if (rq->lsr_category == ScriptCategory::ACTOR)
1495  {
1496  int64_t instance_id; // AngelScript's `Dictionary` converts all ints int `int64`
1497  if (!GetValueFromScriptDict(log_msg, dict, /*required:*/true, "associated_actor", "int64", instance_id))
1498  {
1499  this->log(fmt::format("{}: WARNING, category 'ACTOR' specified but 'associated_actor' not given.", log_msg, rq->lsr_filename));
1500  delete rq;
1501  return false;
1502  }
1503  }
1504  m.payload = rq;
1505  break;
1506  }
1507 
1509  {
1510  int64_t id; // AngelScript's `Dictionary` converts all ints int `int64`
1511  if (!GetValueFromScriptDict(log_msg, dict, /*required:*/true, "id", "int64", id))
1512  {
1513  return false;
1514  }
1515  m.payload = new ScriptUnitID_t(static_cast<ScriptUnitID_t>(id));
1516  break;
1517  }
1518 
1519  // Simulation
1521  if (!GetValueFromScriptDict(log_msg, dict, /*required:*/true, "filename", "string", m.description))
1522  {
1523  return false;
1524  }
1525  break;
1526 
1528  if (!GetValueFromScriptDict(log_msg, dict, /*required:*/true, "filename", "string", m.description))
1529  {
1530  return false;
1531  }
1532  break;
1533 
1535  {
1537 
1538  // Get required params
1539  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "filename", "string", rq->asr_filename) &&
1540  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "position", "vector3", rq->asr_position) &&
1541  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "rotation", "quaternion", rq->asr_rotation))
1542  {
1544  if (!rq->asr_cache_entry)
1545  {
1546  this->log(fmt::format("{}: WARNING, vehicle '{}' is not installed.", log_msg, rq->asr_filename));
1547  delete rq;
1548  return false;
1549  }
1550 
1551  // Set instance ID if specified
1552  GetValueFromScriptDict(log_msg, dict, /*required:*/false, "instance_id", "int", rq->asr_instance_id);
1553 
1554  // Set sectionconfig
1555  GetValueFromScriptDict(log_msg, dict, /*required:*/false, "config", "string", rq->asr_config);
1556  // Make sure config exists
1557  if (rq->asr_config != "")
1558  {
1559  auto result = std::find(rq->asr_cache_entry->sectionconfigs.begin(), rq->asr_cache_entry->sectionconfigs.end(), rq->asr_config);
1560  if (result == rq->asr_cache_entry->sectionconfigs.end())
1561  {
1562  this->log(fmt::format("{}: WARNING, configuration '{}' does not exist in '{}'.", log_msg, rq->asr_config, rq->asr_filename));
1563  rq->asr_config = "";
1564  }
1565  }
1566  // If no config given (or was invalid), use the first available (classic behavior).
1567  if (rq->asr_config == "" && rq->asr_cache_entry->sectionconfigs.size() > 0)
1568  {
1570  }
1571 
1572  // Enter or not?
1573  GetValueFromScriptDict(log_msg, dict, /*required:*/false, "enter", "bool", rq->asr_enter);
1574 
1575  // Get skin
1576  std::string skin_name;
1577  if (GetValueFromScriptDict(log_msg, dict, /*required:*/false, "skin", "string", skin_name))
1578  {
1580  if (!rq->asr_skin_entry)
1581  this->log(fmt::format("{}: WARNING, skin '{}' is not installed.", log_msg, skin_name));
1582  }
1583 
1584  m.payload = rq;
1585  }
1586  else
1587  {
1588  delete rq;
1589  return false;
1590  }
1591  break;
1592  }
1593 
1595  {
1596  ActorModifyRequest::Type modify_type;
1597  // `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
1598  int64_t instance_id = -1;
1599  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "type", "ActorModifyRequestType", modify_type) &&
1600  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "instance_id", "int64", instance_id))
1601  {
1603  rq->amr_type = modify_type;
1604  rq->amr_actor = static_cast<ActorInstanceID_t>(instance_id);
1605  m.payload = rq;
1606  }
1607  else
1608  {
1609  return false;
1610  }
1611  break;
1612  }
1613 
1617  {
1618  // `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
1619  int64_t instance_id = -1;
1620  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "instance_id", "int64", instance_id))
1621  {
1622  ActorPtr actor = App::GetGameContext()->GetActorManager()->GetActorById(instance_id);
1623  if (actor)
1624  {
1625  m.payload = new ActorPtr(actor);
1626  }
1627  else
1628  {
1629  this->log(fmt::format("{}: Actor with instance ID '{}' not found!", log_msg, instance_id));
1630  return false;
1631  }
1632  }
1633  else
1634  {
1635  return false;
1636  }
1637  break;
1638  }
1639 
1641  {
1642  // `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
1643  int64_t instance_id = -1;
1644  ActorPtr actor;
1645  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "instance_id", "int64", instance_id)
1646  && instance_id > -1)
1647  {
1648  actor = App::GetGameContext()->GetActorManager()->GetActorById(instance_id);
1649  }
1650  m.payload = new ActorPtr(actor);
1651  break;
1652  }
1653 
1655  {
1656  Ogre::Vector3 position;
1657  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "position", "vector3", position))
1658  {
1659  m.payload = new Ogre::Vector3(position);
1660  }
1661  else
1662  {
1663  return false;
1664  }
1665  break;
1666  }
1667 
1670  {
1671  // `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
1672  FreeForceRequest* rq = new FreeForceRequest();
1673  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "id", "int64", rq->ffr_id) &&
1674  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "type", "FreeForceType", rq->ffr_type) &&
1675  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "force_magnitude", "double", rq->ffr_force_magnitude) &&
1676  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "base_actor", "int64", rq->ffr_base_actor) &&
1677  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "base_node", "int64", rq->ffr_base_node))
1678  {
1679  switch (rq->ffr_type)
1680  {
1681  case (int64_t)FreeForceType::CONSTANT:
1682  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "force_const_direction", "vector3", rq->ffr_force_const_direction))
1683  {
1684  m.payload = rq;
1685  }
1686  else
1687  {
1688  delete rq;
1689  return false;
1690  }
1691  break;
1692 
1693  case (int64_t)FreeForceType::TOWARDS_COORDS:
1694  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "target_coords", "vector3", rq->ffr_target_coords))
1695  {
1696  m.payload = rq;
1697  }
1698  else
1699  {
1700  delete rq;
1701  return false;
1702  }
1703  break;
1704 
1705  case (int64_t)FreeForceType::TOWARDS_NODE:
1706  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "target_actor", "int64", rq->ffr_target_actor) &&
1707  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "target_node", "int64", rq->ffr_target_node))
1708  {
1709  m.payload = rq;
1710  }
1711  else
1712  {
1713  delete rq;
1714  return false;
1715  }
1716  break;
1717 
1718  default:
1719  this->log(fmt::format("{}: ERROR, invalid 'free force type' value '{}'", log_msg, rq->ffr_type));
1720  delete rq;
1721  return false;
1722  }
1723  m.payload = rq;
1724  }
1725  else
1726  {
1727  delete rq;
1728  return false;
1729  }
1730  break;
1731  }
1732 
1734  {
1735  // `dictionary` converts all primitives to `double` or `int64`, see 'scriptdictionary.cpp', function `Set()`
1736  int64_t id = -1;
1737  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "id", "int64", id))
1738  {
1739  m.payload = new FreeForceID_t(id);
1740  }
1741  else
1742  {
1743  return false;
1744  }
1745  break;
1746  }
1747 
1751  {
1752  CacheEntryPtr entry;
1753  if (GetValueFromScriptDict(log_msg, dict, /*required*/true, "cache_entry", "CacheEntryClass@", entry))
1754  {
1755  m.payload = new CacheEntryPtr(entry);
1756  }
1757  else
1758  {
1759  return false;
1760  }
1761  break;
1762  }
1763 
1765  {
1766  CreateProjectRequest* request = new CreateProjectRequest();
1767  if (GetValueFromScriptDict(log_msg, dict, /*required:*/true, "name", "string", request->cpr_name) &&
1768  GetValueFromScriptDict(log_msg, dict, /*required:*/true, "source_entry", "CacheEntryClass@", request->cpr_source_entry))
1769  {
1770  m.payload = request;
1771  }
1772  else
1773  {
1774  delete request;
1775  return false;
1776  }
1777  break;
1778  }
1779 
1780  default:;
1781  }
1782 
1784  return true;
1785 }
1786 
1787 FreeForceID_t GameScript::getFreeForceNextId()
1788 {
1789  return App::GetGameContext()->GetActorManager()->GetFreeForceNextId();
1790 }
1791 
1792 ActorInstanceID_t GameScript::getActorNextInstanceId()
1793 {
1794  return App::GetGameContext()->GetActorManager()->GetActorNextInstanceId();
1795 }
1796 
1797 // --------------------------------
1798 // Audio
1799 
1800 CScriptArray* GameScript::getAllSoundScriptTemplates()
1801 {
1802  return MapToScriptArray(App::GetSoundScriptManager()->getAllTemplates(), "SoundScriptTemplateClass@");
1803 }
1804 
1805 SoundScriptTemplatePtr GameScript::getSoundScriptTemplate(const std::string& name)
1806 {
1807  return App::GetSoundScriptManager()->getTemplate(name);
1808 }
1809 
1810 AngelScript::CScriptArray* GameScript::getAllSoundScriptInstances()
1811 {
1812  return VectorToScriptArray(App::GetSoundScriptManager()->getAllInstances(), "SoundScriptInstanceClass@");
1813 }
1814 
1815 SoundPtr GameScript::createSoundFromResource(const std::string& filename, const std::string& resource_group_name)
1816 {
1817  return App::GetSoundScriptManager()->getSoundManager()->createSound(filename, resource_group_name);
1818 }
1819 
1820 SoundScriptInstancePtr GameScript::createSoundScriptInstance(const std::string& template_name, int actor_instance_id = SoundScriptInstance::ACTOR_ID_UNKNOWN)
1821 {
1822  return App::GetSoundScriptManager()->createInstance(template_name, actor_instance_id);
1823 }
1824 
1825 bool GameScript::checkResourceExists(const std::string& filename, const std::string& resource_group)
1826 {
1827  try
1828  {
1829  std::string resource_name = this->CheckFileAccess("checkResourceExists()", filename, resource_group);
1830  if (resource_name == "")
1831  return false; // Access denied - error already logged
1832 
1833  // Actually check for the resource
1834  return Ogre::ResourceGroupManager::getSingleton().resourceExists(resource_group, resource_name);
1835  }
1836  catch (...)
1837  {
1838  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::checkResourceExists()");
1839  return false;
1840  }
1841 }
1842 
1843 bool GameScript::deleteResource(const std::string& filename, const std::string& resource_group)
1844 {
1845  try
1846  {
1847  std::string resource_name = this->CheckFileAccess("deleteResource()", filename, resource_group);
1848  if (resource_name == "")
1849  return false; // Access denied - error already logged
1850 
1851  // Actually delete the resource
1852  Ogre::ResourceGroupManager::getSingleton().deleteResource(resource_name, resource_group);
1853  return true;
1854  }
1855  catch (...)
1856  {
1857  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::deleteResource()");
1858  return false;
1859  }
1860 }
1861 
1862 std::string GameScript::loadTextResourceAsString(const std::string& filename, const std::string& resource_group)
1863 {
1864  try
1865  {
1866  std::string resource_name = this->CheckFileAccess("loadTextResourceAsString()", filename, resource_group);
1867  if (resource_name == "")
1868  return ""; // Access denied - error already logged
1869 
1870  Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(resource_name, resource_group);
1871 
1872  if (stream.isNull() || !stream->isReadable())
1873  {
1874  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_SCRIPT, Console::CONSOLE_SYSTEM_ERROR,
1875  fmt::format("loadTextResourceAsString() could not read resource '{}' in group '{}'",
1876  resource_name, resource_group));
1877  return "";
1878  }
1879 
1880 #if OGRE_PLATFORM == OGRE_PLATFORM_LINUX
1881  // WORKAROUND: apparently `getAsString()` has some Linux-x64 issues (`eof()` triggers SIGINT):
1882  // https://discord.com/channels/136544456244461568/189904947649708032/1155952230130778262
1883  // Observed with OGRE 1.11.6
1884  std::string str;
1885  const size_t BUF_LEN = 4000;
1886  char buf[BUF_LEN] = {};
1887  bool eof = false;
1888  while (!eof)
1889  {
1890  size_t read_len = stream->read(buf, BUF_LEN);
1891  if (read_len < BUF_LEN)
1892  {
1893  buf[read_len] = 0;
1894  eof = true;
1895  }
1896  str.append(buf, read_len);
1897  }
1898  return str;
1899 #else
1900  return stream->getAsString();
1901 #endif
1902  }
1903  catch (...)
1904  {
1905  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::loadTextResourceAsString()");
1906  return "";
1907  }
1908 }
1909 
1910 bool GameScript::createTextResourceFromString(const std::string& data, const std::string& filename, const std::string& resource_group, bool overwrite/*=false*/)
1911 {
1912  try
1913  {
1914  std::string resource_name = this->CheckFileAccess("createTextResourceFromString()", filename, resource_group);
1915  if (resource_name == "")
1916  return false; // Access denied - error already logged
1917 
1918  Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().createResource(resource_name, resource_group, overwrite);
1919 
1920  if (stream.isNull() || !stream->isWriteable())
1921  {
1922  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_SCRIPT, Console::CONSOLE_SYSTEM_ERROR,
1923  fmt::format("createTextResourceFromString() could not create resource '{}' in group '{}'",
1924  resource_name, resource_group));
1925  return false;
1926  }
1927 
1928  stream->write(data.data(), data.size());
1929  return true;
1930  }
1931  catch (...)
1932  {
1933  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::createTextResourceFromString()");
1934  return false;
1935  }
1936 }
1937 
1938 AngelScript::CScriptArray* GameScript::findResourceFileInfo(const std::string& resource_group, const std::string& pattern, bool dirs /*= false*/)
1939 {
1940  try
1941  {
1942  // Search the file system
1943  Ogre::FileInfoListPtr fileInfoList
1944  = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(resource_group, pattern, dirs);
1945 
1946  // Put results to array
1947  AngelScript::asITypeInfo* typeinfo = App::GetScriptEngine()->getEngine()->GetTypeInfoByDecl("array<dictionary>");
1948  AngelScript::CScriptArray* arr = AngelScript::CScriptArray::Create(typeinfo);
1949  int stringTypeid = App::GetScriptEngine()->getEngine()->GetTypeIdByDecl("string");
1950  for (const Ogre::FileInfo& fileinfo: *fileInfoList)
1951  {
1952  AngelScript::CScriptDictionary* dict = AngelScript::CScriptDictionary::Create(App::GetScriptEngine()->getEngine());
1953  dict->Set("filename", new std::string(fileinfo.filename), stringTypeid);
1954  dict->Set("basename", new std::string(fileinfo.basename), stringTypeid);
1955  dict->Set("compressedSize", (asINT64)fileinfo.compressedSize);
1956  dict->Set("uncompressedSize", (asINT64)fileinfo.uncompressedSize);
1957 
1958  arr->InsertLast(dict);
1959  }
1960  return arr;
1961  }
1962  catch (...)
1963  {
1964  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::findResourceFileInfo()");
1965  return nullptr;
1966  }
1967 }
1968 
1969 Ogre::Image GameScript::loadImageResource(const std::string& filename, const std::string& resource_group)
1970 {
1971  try
1972  {
1973  std::string resource_name = this->CheckFileAccess("loadImageResource()", filename, resource_group);
1974  if (resource_name == "")
1975  return Ogre::Image(); // Access denied - error already logged
1976 
1977  Ogre::Image img;
1978  return img.load(resource_name, resource_group);
1979  }
1980  catch (...)
1981  {
1982  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::loadImageResource()");
1983  return Ogre::Image();
1984  }
1985 }
1986 
1987 bool GameScript::serializeMeshResource(const std::string& filename, const std::string& resource_group, const Ogre::MeshPtr& mesh)
1988 {
1989  try
1990  {
1991  std::string resource_name = this->CheckFileAccess("serializeMeshResource()", filename, resource_group);
1992  if (resource_name == "")
1993  return false; // Access denied - error already logged
1994 
1995  Ogre::MeshSerializer ser;
1996  Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().createResource(resource_name, resource_group);
1997  ser.exportMesh(mesh.get(), stream);
1998  return true;
1999  }
2000  catch (...)
2001  {
2002  App::GetScriptEngine()->forwardExceptionAsScriptEvent("GameScript::serializeMeshResource()");
2003  return false;
2004  }
2005 }
2006 
2007 // ------------------------
2008 // Helpers:
2009 
2010 bool GameScript::HaveSimTerrain(const char* func_name)
2011 {
2012  if (App::GetGameContext()->GetTerrain() == nullptr)
2013  {
2014  this->logFormat("Cannot execute '%s', terrain not ready", func_name);
2015  return false;
2016  }
2017  return true;
2018 }
2019 
2020 bool GameScript::HavePlayerAvatar(const char* func_name)
2021 {
2022  if (App::GetGameContext()->GetPlayerCharacter() == nullptr)
2023  {
2024  this->logFormat("Cannot execute '%s', player avatar not ready", func_name);
2025  return false;
2026  }
2027  return true;
2028 }
2029 
2030 bool GameScript::HaveMainCamera(const char* func_name)
2031 {
2032  if (App::GetCameraManager()->GetCamera() == nullptr)
2033  {
2034  this->logFormat("Cannot execute '%s', main camera not ready", func_name);
2035  return false;
2036  }
2037  return true;
2038 }
2039 
2040 std::string GameScript::CheckFileAccess(const char* func_name, const std::string& filename, const std::string& resource_group)
2041 {
2042  // Extract filename and extension from the input, because OGRE allows absolute paths in resource system.
2043  // -----------------------------------------------------------------------------------------------------
2044 
2045  std::string basename, extension, path;
2046  Ogre::StringUtil::splitFullFilename(filename, basename, extension, path);
2047  if (path != "")
2048  {
2049  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_SCRIPT, Console::CONSOLE_SYSTEM_ERROR,
2050  fmt::format("{}: access denied to '{}' with group '{}' - file paths are not allowed",
2051  func_name, filename, resource_group));
2052  return "";
2053  }
2054  else
2055  {
2056  return basename + "." + extension;
2057  }
2058 }
RoR::ScriptUnit
Represents a loaded script and all associated resources/handles.
Definition: ScriptEngine.h:69
GameContext.h
Game state manager and message-queue provider.
RoR::MSG_SIM_LOAD_TERRN_REQUESTED
@ MSG_SIM_LOAD_TERRN_REQUESTED
Definition: Application.h:118
RoR::Character::getRotation
Ogre::Radian getRotation() const
Definition: Character.h:54
ScriptRayQueryListener
Definition: GameScript.cpp:1403
RoR::IWater::GetStaticWaterHeight
virtual float GetStaticWaterHeight()=0
Returns static water level configured in 'terrn2'.
RoR::App::GetNetwork
Network * GetNetwork()
Definition: Application.cpp:287
RoR::MSG_SIM_REMOVE_FREEFORCE_REQUESTED
@ MSG_SIM_REMOVE_FREEFORCE_REQUESTED
Payload = RoR::FreeForceID_t* (owner)
Definition: Application.h:135
RoR::Character::setPosition
void setPosition(Ogre::Vector3 position)
Definition: Character.cpp:85
RoR::LoadScriptRequest::lsr_filename
std::string lsr_filename
Load from resource (file). If buffer is supplied, use this as display name only.
Definition: ScriptEngine.h:92
RoR::App::GetSoundScriptManager
SoundScriptManager * GetSoundScriptManager()
Definition: Application.cpp:280
Script2Game::log
void log(const string message)
This is an alias for game.log(string message).
RoR::MSG_GUI_SHOW_MESSAGE_BOX_REQUESTED
@ MSG_GUI_SHOW_MESSAGE_BOX_REQUESTED
Payload = MessageBoxConfig* (owner)
Definition: Application.h:142
RoR::GUI::TopMenubar::ai_fname2
Ogre::String ai_fname2
Definition: GUI_TopMenubar.h:89
RoR::Actor::ar_vehicle_ai
VehicleAIPtr ar_vehicle_ai
Definition: Actor.h:394
RoR::VectorToScriptArray
AngelScript::CScriptArray * VectorToScriptArray(const std::vector< T > &vec, const std::string &decl)
Definition: ScriptUtils.h:42
RoR::GUI::TopMenubar::ai_fname
Ogre::String ai_fname
Definition: GUI_TopMenubar.h:78
RoR::GUI::TopMenubar::ai_num
int ai_num
Definition: GUI_TopMenubar.h:72
RoR::MSG_SIM_MODIFY_ACTOR_REQUESTED
@ MSG_SIM_MODIFY_ACTOR_REQUESTED
Payload = RoR::ActorModifyRequest* (owner)
Definition: Application.h:122
RoR::MSG_EDI_RELOAD_BUNDLE_REQUESTED
@ MSG_EDI_RELOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:153
RoR::FreeForceRequest::ffr_target_node
int64_t ffr_target_node
Definition: SimData.h:799
RoR::OpenUrlInDefaultBrowser
void OpenUrlInDefaultBrowser(std::string const &url)
Definition: PlatformUtils.cpp:199
RoR::Actor::ar_filename
std::string ar_filename
Attribute; filled at spawn.
Definition: Actor.h:422
RoR::MpState::CONNECTED
@ CONNECTED
RoR::CurlTaskContext::ctc_msg_progress
MsgType ctc_msg_progress
Definition: CurlHelpers.h:39
RoR::RaceSystem::UpdateDirectionArrow
void UpdateDirectionArrow(char *text, Ogre::Vector3 position)
Definition: RaceSystem.cpp:31
RoR::SCRIPTUNITID_INVALID
static const ScriptUnitID_t SCRIPTUNITID_INVALID
Definition: ForwardDeclarations.h:42
RoR::MSG_NET_USER_DISCONNECT
@ MSG_NET_USER_DISCONNECT
Definition: Application.h:104
RoR::App::GetCameraManager
CameraManager * GetCameraManager()
Definition: Application.cpp:278
RoR::ActorSpawnRequest::asr_origin
Origin asr_origin
Definition: SimData.h:839
RoR::CacheEntryPtr
RefCountingObjectPtr< CacheEntry > CacheEntryPtr
Definition: ForwardDeclarations.h:220
VehicleAI.h
Simple waypoint AI.
RoR::App::GetGuiManager
GUIManager * GetGuiManager()
Definition: Application.cpp:272
RoR::App::mp_api_url
CVar * mp_api_url
Definition: Application.cpp:126
RoR::MSG_EDI_CREATE_PROJECT_REQUESTED
@ MSG_EDI_CREATE_PROJECT_REQUESTED
Payload = RoR::CreateProjectRequest* (owner)
Definition: Application.h:155
RoR::ScriptUnit::eventMask
unsigned int eventMask
filter mask for script events
Definition: ScriptEngine.h:76
RoR::GUI::TopMenubar::ai_position_scheme
int ai_position_scheme
Definition: GUI_TopMenubar.h:77
RoR::Actor::ar_linked_actors
ActorPtrVec ar_linked_actors
BEWARE: Includes indirect links, see DetermineLinkedActors(); Other actors linked using 'hooks/ties/r...
Definition: Actor.h:454
RoR::MSG_EDI_UNLOAD_BUNDLE_REQUESTED
@ MSG_EDI_UNLOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:154
RoR::App::mp_player_name
CVar * mp_player_name
Definition: Application.cpp:124
RoR::Actor::ar_instance_id
ActorInstanceID_t ar_instance_id
Static attr; session-unique ID.
Definition: Actor.h:373
SkyManager.h
RoR::ScriptEngine::deleteVariable
ScriptRetCode_t deleteVariable(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Deletes a global variable from the script.
Definition: ScriptEngine.cpp:656
ScriptRayQueryListener::queryResult
bool queryResult(MovableObject *obj, Real distance) override
Definition: GameScript.cpp:1409
RoR::MSG_SIM_UNLOAD_TERRN_REQUESTED
@ MSG_SIM_UNLOAD_TERRN_REQUESTED
Definition: Application.h:120
GUI_TopMenubar.h
RoR::AppContext::GetRenderWindow
Ogre::RenderWindow * GetRenderWindow()
Definition: AppContext.h:67
RoR::App::GetAppContext
AppContext * GetAppContext()
Definition: Application.cpp:269
RoR::GUI::TopMenubar::ai_skin2
std::string ai_skin2
Definition: GUI_TopMenubar.h:92
format
Truck file format(technical spec)
RoR::Terrain::getObjectManager
TerrainObjectManager * getObjectManager()
Definition: Terrain.h:76
RoR::RaceSystem::SetRaceBestTime
void SetRaceBestTime(float time)
Definition: RaceSystem.h:44
RoR::Terrain::getSkyManager
SkyManager * getSkyManager()
Definition: Terrain.cpp:514
RoR::MSG_NET_CONNECT_STARTED
@ MSG_NET_CONNECT_STARTED
Definition: Application.h:98
RoR::MSG_GUI_DOWNLOAD_PROGRESS
@ MSG_GUI_DOWNLOAD_PROGRESS
Definition: Application.h:144
TerrainGeometryManager.h
RoR::Collisions::clearEventCache
void clearEventCache()
Definition: Collisions.h:201
RoR::GameContext::GetPlayerCharacter
Character * GetPlayerCharacter()
Definition: GameContext.cpp:893
RoR::Terrain::setGravity
void setGravity(float value)
Definition: Terrain.cpp:482
RoR::ScriptEngine::addFunction
ScriptRetCode_t addFunction(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Adds a global function to the script.
Definition: ScriptEngine.cpp:519
RoR::SoundScriptManager::getSoundManager
SoundManager * getSoundManager()
Definition: SoundScriptManager.h:336
RoR::IWater
< TODO: Mixed gfx+physics (waves) - must be separated ~ only_a_ptr, 02/2018
Definition: IWater.h:32
RoR::MsgTypeToString
const char * MsgTypeToString(MsgType type)
Definition: Application.cpp:572
RoR::CurlTaskContext::ctc_msg_failure
MsgType ctc_msg_failure
Sent on failure; Payload: RoR::ScriptEventArgs (see 'gameplay/ScriptEvents.h') with args for RoR::SE_...
Definition: CurlHelpers.h:41
RoR::TerrainEditorObjectPtrVec
std::vector< TerrainEditorObjectPtr > TerrainEditorObjectPtrVec
Definition: ForwardDeclarations.h:238
AppContext.h
System integration layer; inspired by OgreBites::ApplicationContext.
RoR::MSG_NET_REFRESH_SERVERLIST_FAILURE
@ MSG_NET_REFRESH_SERVERLIST_FAILURE
Payload = RoR::CurlFailInfo* (owner)
Definition: Application.h:107
Console.h
RoR::ScriptEngine::getEngine
AngelScript::asIScriptEngine * getEngine()
Definition: ScriptEngine.h:289
RoR::Console::putMessage
void putMessage(MessageArea area, MessageType type, std::string const &msg, std::string icon="")
Definition: Console.cpp:103
RoR::LoadScriptRequest::lsr_buffer
std::string lsr_buffer
Load from memory buffer.
Definition: ScriptEngine.h:93
RoR::MSG_NET_RECV_ERROR
@ MSG_NET_RECV_ERROR
Definition: Application.h:105
RoR::GetValueFromScriptDict
bool GetValueFromScriptDict(const std::string &log_msg, AngelScript::CScriptDictionary *dict, bool required, std::string const &key, const char *decl, T &out_value)
Definition: ScriptUtils.h:108
RoR::LT_Load
@ LT_Load
Definition: Application.h:317
RoR::ActorManager::GetActors
ActorPtrVec & GetActors()
Definition: ActorManager.h:118
RoR::LT_Airplane
@ LT_Airplane
Definition: Application.h:314
RoR::ScriptEngine::setForwardScriptLogToConsole
void setForwardScriptLogToConsole(bool doForward)
Definition: ScriptEngine.cpp:1051
RoR::ScriptEngine::forwardExceptionAsScriptEvent
void forwardExceptionAsScriptEvent(const std::string &from)
Forwards useful info from C++ try{}catch{} exceptions to script in the form of game event.
Definition: ScriptEngine.cpp:247
RoR::TerrainObjectManager::destroyObject
void destroyObject(const Ogre::String &instancename)
Definition: TerrainObjectManager.cpp:504
RoR::GetUrlAsStringMQ
bool GetUrlAsStringMQ(CurlTaskContext task)
Definition: CurlHelpers.cpp:106
RoR::MSG_APP_LOAD_SCRIPT_REQUESTED
@ MSG_APP_LOAD_SCRIPT_REQUESTED
Payload = RoR::LoadScriptRequest* (owner)
Definition: Application.h:92
RoR::GUI::TopMenubar::ai_waypoints
std::vector< ai_events > ai_waypoints
Definition: GUI_TopMenubar.h:68
RoR::App::app_country
CVar * app_country
Definition: Application.cpp:81
RoR::TerrainObjectManager::LoadTerrainObject
bool LoadTerrainObject(const Ogre::String &name, const Ogre::Vector3 &pos, const Ogre::Vector3 &rot, const Ogre::String &instancename, const Ogre::String &type, float rendering_distance=0, bool enable_collisions=true, int scripthandler=-1, bool uniquifyMaterial=false)
Definition: TerrainObjectManager.cpp:600
RoR::LT_Car
@ LT_Car
Definition: Application.h:312
Engine.h
RoR::CacheEntry::sectionconfigs
std::vector< Ogre::String > sectionconfigs
Definition: CacheSystem.h:142
RoR::CameraManager::GetCameraNode
Ogre::SceneNode * GetCameraNode()
Definition: CameraManager.h:63
Utils.h
RoR::App::app_disable_online_api
CVar * app_disable_online_api
Definition: Application.cpp:90
RoR::ActorSpawnRequest::asr_filename
std::string asr_filename
Can be in "Bundle-qualified" format, i.e. "mybundle.zip:myactor.truck".
Definition: SimData.h:831
Language.h
RoR::FreeForceRequest::ffr_base_actor
int64_t ffr_base_actor
Definition: SimData.h:793
RoR::LT_Extension
@ LT_Extension
Definition: Application.h:318
TerrainObjectManager.h
RoR::SoundScriptManager::getTemplate
SoundScriptTemplatePtr getTemplate(Ogre::String name)
Definition: SoundScriptManager.h:308
RefCountingObjectPtr< Actor >
RoR::World2ScreenConverter::Convert
Ogre::Vector3 Convert(Ogre::Vector3 world_pos)
Definition: Utils.h:89
RoR::MSG_NET_SERVER_KICK
@ MSG_NET_SERVER_KICK
Definition: Application.h:102
GUIManager.h
RoR::CreateProjectRequest::cpr_source_entry
CacheEntryPtr cpr_source_entry
The original mod to copy files from.
Definition: CacheSystem.h:226
ActorManager.h
Actor.h
RoR::CreateProjectRequest::cpr_name
std::string cpr_name
Directory and also the mod file (without extension).
Definition: CacheSystem.h:224
RoR::App::GetScriptEngine
ScriptEngine * GetScriptEngine()
Definition: Application.cpp:282
RoR::Terrain::getTerrainName
std::string getTerrainName() const
Definition: Terrain.cpp:579
RoR::GfxScene::GetSceneManager
Ogre::SceneManager * GetSceneManager()
Definition: GfxScene.h:69
RoR::ScriptEngine::getFunctionByDeclAndLogCandidates
AngelScript::asIScriptFunction * getFunctionByDeclAndLogCandidates(ScriptUnitID_t nid, GetFuncFlags_t flags, const std::string &funcName, const std::string &fmtFuncDecl)
Finds a function by full declaration, and if not found, finds candidates by name and logs them to Ang...
Definition: ScriptEngine.cpp:759
RoR::ActorSpawnRequest
Definition: SimData.h:813
RoR::GameContext::GetRaceSystem
RaceSystem & GetRaceSystem()
Definition: GameContext.h:168
RoR::SoundManager::createSound
SoundPtr createSound(Ogre::String filename, Ogre::String resource_group_name="")
Definition: SoundManager.cpp:354
RoR::ActorManager::GetTotalTime
float GetTotalTime() const
Definition: ActorManager.h:95
RoR::GameContext::SpawnActor
ActorPtr SpawnActor(ActorSpawnRequest &rq)
Definition: GameContext.cpp:193
RoR::Terrain::GetHeightAt
float GetHeightAt(float x, float z)
Definition: Terrain.cpp:504
RoR::IWater::UpdateWater
virtual void UpdateWater()=0
RoR::LT_Boat
@ LT_Boat
Definition: Application.h:313
RoR::MSG_NET_REFRESH_SERVERLIST_SUCCESS
@ MSG_NET_REFRESH_SERVERLIST_SUCCESS
Payload = GUI::MpServerInfoVec* (owner)
Definition: Application.h:106
RoR::App::mp_state
CVar * mp_state
Definition: Application.cpp:115
RoR::FreeForceRequest::ffr_force_const_direction
Ogre::Vector3 ffr_force_const_direction
Definition: SimData.h:796
RoR::MSG_GUI_DOWNLOAD_FINISHED
@ MSG_GUI_DOWNLOAD_FINISHED
Definition: Application.h:145
RoR::GUI::TopMenubar::ai_speed
int ai_speed
Definition: GUI_TopMenubar.h:73
RoR::ActorModifyRequest::amr_actor
ActorInstanceID_t amr_actor
Definition: SimData.h:871
RoR::LT_Truck
@ LT_Truck
Definition: Application.h:311
RoR::LoadScriptRequest::lsr_category
ScriptCategory lsr_category
Definition: ScriptEngine.h:94
RoR::MSG_NET_FETCH_AI_PRESETS_FAILURE
@ MSG_NET_FETCH_AI_PRESETS_FAILURE
Description = message.
Definition: Application.h:112
RoR::ActorSpawnRequest::asr_config
Ogre::String asr_config
Definition: SimData.h:832
RoR::MapToScriptArray
AngelScript::CScriptArray * MapToScriptArray(std::map< T, U > &map, const std::string &decl)
Definition: ScriptUtils.h:59
RoR::CameraManager::GetCamera
Ogre::Camera * GetCamera()
Definition: CameraManager.h:64
RoR::InputEngine::getMouseNormalizedScreenPos
Ogre::Vector2 getMouseNormalizedScreenPos()
Returns XY position in range from 0 (top/left) to 1 (bottom/right)
Definition: InputEngine.cpp:1710
RoR::ActorInstanceID_t
int ActorInstanceID_t
Unique sequentially generated ID of an actor in session. Use ActorManager::GetActorById()
Definition: ForwardDeclarations.h:38
RoR::RaceSystem::StopRaceTimer
void StopRaceTimer()
Definition: RaceSystem.cpp:53
RoRnet::MSG2_GAME_CMD
@ MSG2_GAME_CMD
Script message. Can be sent in both directions.
Definition: RoRnet.h:56
RoR::CVar::getStr
std::string const & getStr() const
Definition: CVar.h:95
RoR::ScriptEngine::variableExists
ScriptRetCode_t variableExists(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Adds a global variable to the script.
Definition: ScriptEngine.cpp:640
RoR::FreeForceRequest::ffr_base_node
int64_t ffr_base_node
Definition: SimData.h:794
RoR::CacheSystem::FindEntryByFilename
CacheEntryPtr FindEntryByFilename(RoR::LoaderType type, bool partial, const std::string &_filename_maybe_bundlequalified)
Returns NULL if none found; "Bundle-qualified" format also specifies the ZIP/directory in modcache,...
Definition: CacheSystem.cpp:184
ScriptRayQueryListener::ray
Ogre::Ray ray
Definition: GameScript.cpp:1406
RoR::Actor::ar_engine
EnginePtr ar_engine
Definition: Actor.h:376
RoR::Character::move
void move(Ogre::Vector3 offset)
Definition: Character.cpp:401
RoR::ActorModifyRequest
Definition: SimData.h:853
RoR::Engine::getRPM
float getRPM()
Definition: Engine.h:94
RoR::ScriptUnit::scriptName
Ogre::String scriptName
Definition: ScriptEngine.h:83
RoR::MSG_SIM_SEAT_PLAYER_REQUESTED
@ MSG_SIM_SEAT_PLAYER_REQUESTED
Payload = RoR::ActorPtr (owner) | nullptr.
Definition: Application.h:124
CacheSystem.h
A database of user-installed content alias 'mods' (vehicles, terrains...)
RoR::ActorPtrVec
std::vector< ActorPtr > ActorPtrVec
Definition: ForwardDeclarations.h:237
CurlHelpers.h
RoR::GUI::TopMenubar::ai_times
int ai_times
Definition: GUI_TopMenubar.h:74
RoR::ActorSpawnRequest::asr_cache_entry
CacheEntryPtr asr_cache_entry
Optional, overrides 'asr_filename' and 'asr_cache_entry_num'.
Definition: SimData.h:830
ScriptEngine.h
RoR::World2ScreenConverter
< Keeps data close for faster access.
Definition: Utils.h:81
RoR::ScriptUnit::scriptCategory
ScriptCategory scriptCategory
Definition: ScriptEngine.h:75
RoR::GameContext::PushMessage
void PushMessage(Message m)
Doesn't guarantee order! Use ChainMessage() if order matters.
Definition: GameContext.cpp:66
RoR::Terrain::getGeometryManager
TerrainGeometryManager * getGeometryManager()
Definition: Terrain.h:74
ChatSystem.h
RoR::App::sim_terrain_name
CVar * sim_terrain_name
Definition: Application.cpp:97
RoR::FreeForceID_t
int FreeForceID_t
Unique sequentially generated ID of FreeForce; use ActorManager::GetFreeForceNextId().
Definition: ForwardDeclarations.h:67
RoR::Terrain::GetCollisions
Collisions * GetCollisions()
Definition: Terrain.h:82
RoR::FreeForceRequest::ffr_target_coords
Ogre::Vector3 ffr_target_coords
Definition: SimData.h:797
GfxScene.h
PlatformUtils.h
Platform-specific utilities. We use narrow UTF-8 encoded strings as paths. Inspired by http://utf8eve...
RoR::MSG_NET_REFRESH_REPOLIST_FAILURE
@ MSG_NET_REFRESH_REPOLIST_FAILURE
Payload = RoR::CurlFailInfo* (owner)
Definition: Application.h:110
Character.h
RoR::MSG_GUI_OPEN_SELECTOR_REQUESTED
@ MSG_GUI_OPEN_SELECTOR_REQUESTED
Payload = LoaderType* (owner), Description = GUID | empty.
Definition: Application.h:139
RoR::LT_Vehicle
@ LT_Vehicle
Definition: Application.h:310
RoR::LT_Trailer
@ LT_Trailer
Definition: Application.h:315
RoR::MSG_SIM_HIDE_NET_ACTOR_REQUESTED
@ MSG_SIM_HIDE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:126
RoR::SoundScriptManager::createInstance
SoundScriptInstancePtr createInstance(Ogre::String templatename, int actor_id, int soundLinkType=SL_DEFAULT, int soundLinkItemId=-1)
Definition: SoundScriptManager.cpp:356
RoR::LoaderType
LoaderType
< Search mode for ModCache::Query() & Operation mode for GUI::MainSelector
Definition: Application.h:306
RoR::MSG_SIM_ADD_FREEFORCE_REQUESTED
@ MSG_SIM_ADD_FREEFORCE_REQUESTED
Payload = RoR::FreeForceRequest* (owner)
Definition: Application.h:133
RoR::MsgType
MsgType
Global gameplay message loop, see struct Message in GameContext.h.
Definition: Application.h:74
RoR::GUI::TopMenubar::ai_skin
std::string ai_skin
Definition: GUI_TopMenubar.h:81
RoR::App::GetConsole
Console * GetConsole()
Definition: Application.cpp:273
RoR::MSG_NET_OPEN_RESOURCE_SUCCESS
@ MSG_NET_OPEN_RESOURCE_SUCCESS
Payload = GUI::ResourcesCollection* (owner)
Definition: Application.h:109
SoundScriptManager.h
RoR::MSG_APP_MODCACHE_LOAD_REQUESTED
@ MSG_APP_MODCACHE_LOAD_REQUESTED
Definition: Application.h:89
RoR::Message::payload
void * payload
Definition: GameContext.h:59
RoR::App::GetGameContext
GameContext * GetGameContext()
Definition: Application.cpp:283
GameScript.h
RoR::Character::getPosition
Ogre::Vector3 getPosition()
Definition: Character.cpp:92
RoR::FreeForceRequest::ffr_force_magnitude
double ffr_force_magnitude
Definition: SimData.h:792
RoR::MSG_NET_REFRESH_REPOLIST_SUCCESS
@ MSG_NET_REFRESH_REPOLIST_SUCCESS
Payload = GUI::ResourcesCollection* (owner)
Definition: Application.h:108
RoRVersion.h
RoR::TerrainObjectManager::GetEditorObjects
TerrainEditorObjectPtrVec & GetEditorObjects()
Definition: TerrainObjectManager.h:66
RoR::ActorSpawnRequest::asr_skin_entry
CacheEntryPtr asr_skin_entry
Definition: SimData.h:836
RoR::LoadScriptRequest
Definition: ScriptEngine.h:90
ROR_VERSION_STRING
const char *const ROR_VERSION_STRING
RoR::MSG_SIM_TELEPORT_PLAYER_REQUESTED
@ MSG_SIM_TELEPORT_PLAYER_REQUESTED
Payload = Ogre::Vector3* (owner)
Definition: Application.h:125
RoR::Message::description
std::string description
Definition: GameContext.h:58
RoR::RaceSystem::StartRaceTimer
void StartRaceTimer(int id)
Definition: RaceSystem.cpp:46
RoR::CurlTaskContext::ctc_url
std::string ctc_url
Definition: CurlHelpers.h:37
RoR::GUIManager::TopMenubar
GUI::TopMenubar TopMenubar
Definition: GUIManager.h:131
RoR::GUI::TopMenubar::ai_sectionconfig2
Ogre::String ai_sectionconfig2
Definition: GUI_TopMenubar.h:91
RoR::MSG_EDI_LOAD_BUNDLE_REQUESTED
@ MSG_EDI_LOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:152
RoR::GUIManager::ShowMessageBox
void ShowMessageBox(const char *title, const char *text, bool allow_close=true, const char *btn1_text="OK", const char *btn2_text=nullptr)
Definition: GUIManager.cpp:454
RoR::MSG_NET_CONNECT_SUCCESS
@ MSG_NET_CONNECT_SUCCESS
Definition: Application.h:100
RoR::CreateProjectRequest
Creates subdirectory in 'My Games\Rigs of Rods\projects', pre-populates it with files and adds modcac...
Definition: CacheSystem.h:219
RoR::ScriptUnit::scriptHash
Ogre::String scriptHash
Definition: ScriptEngine.h:84
RoR::MSG_NET_FETCH_AI_PRESETS_SUCCESS
@ MSG_NET_FETCH_AI_PRESETS_SUCCESS
Description = JSON string.
Definition: Application.h:111
RoR::App::GetCacheSystem
CacheSystem * GetCacheSystem()
Definition: Application.cpp:275
RoR::GETFUNC_DEFAULTEVENTCALLBACK_SIGFMT
const std::string GETFUNC_DEFAULTEVENTCALLBACK_SIGFMT
Definition: ScriptEngine.h:112
RoR::Sha1Hash
std::string Sha1Hash(std::string const &data)
Definition: Utils.cpp:138
RoR::CacheSystem::FetchSkinByName
CacheEntryPtr FetchSkinByName(std::string const &skin_name)
Definition: CacheSystem.cpp:1565
RoR::GUI::TopMenubar::ai_mode
int ai_mode
Definition: GUI_TopMenubar.h:84
RoR::CurlTaskContext::ctc_displayname
std::string ctc_displayname
Definition: CurlHelpers.h:36
instance
or anywhere else will not be considered a but parsed as regular data ! Each line is treated as values separated by separators Possible i e animators Multiline description Single instance
Definition: ReadMe.txt:53
RoR::FreeForceRequest
Common for ADD and MODIFY requests; tailored for use with AngelScript thru GameScript::pushMessage().
Definition: SimData.h:785
RoR::ScriptEngine::getVariable
ScriptRetCode_t getVariable(const Ogre::String &varName, void *ref, int typeID, ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Retrieves a global variable from any running script.
Definition: ScriptEngine.cpp:676
RoR::GETFUNCFLAG_REQUIRED
const GetFuncFlags_t GETFUNCFLAG_REQUIRED
Always logs warning that function was not found.
Definition: ScriptEngine.h:108
RoR::ScriptEngine::addVariable
ScriptRetCode_t addVariable(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Adds a global variable to the script.
Definition: ScriptEngine.cpp:624
RoR::Message
Unified game event system - all requests and state changes are reported using a message.
Definition: GameContext.h:51
RoR::ScriptEngine::getScriptUnit
ScriptUnit & getScriptUnit(ScriptUnitID_t unique_id)
Definition: ScriptEngine.cpp:1069
RoR::MSG_GUI_OPEN_MENU_REQUESTED
@ MSG_GUI_OPEN_MENU_REQUESTED
Definition: Application.h:137
_L
#define _L
Definition: ErrorUtils.cpp:34
RoR::LT_None
@ LT_None
Definition: Application.h:308
RoR::ScriptUnit::uniqueId
ScriptUnitID_t uniqueId
Definition: ScriptEngine.h:74
RoR::ActorManager::SetTrucksForcedAwake
void SetTrucksForcedAwake(bool forced)
Definition: ActorManager.h:89
RoR::TerrainObjectManager::moveObjectVisuals
void moveObjectVisuals(const Ogre::String &instancename, const Ogre::Vector3 &pos)
Definition: TerrainObjectManager.cpp:489
RoR::MSG_SIM_SPAWN_ACTOR_REQUESTED
@ MSG_SIM_SPAWN_ACTOR_REQUESTED
Payload = RoR::ActorSpawnRequest* (owner)
Definition: Application.h:121
RoR::App::GetInputEngine
InputEngine * GetInputEngine()
Definition: Application.cpp:274
ScriptRayQueryListener::results_array
std::vector< Ogre::MovableObject * > results_array
Definition: GameScript.cpp:1407
RoR::Engine::setRPM
void setRPM(float rpm)
Definition: Engine.cpp:918
RoR::ActorPtr
RefCountingObjectPtr< Actor > ActorPtr
Definition: ForwardDeclarations.h:219
RoR::MSG_NET_CONNECT_FAILURE
@ MSG_NET_CONNECT_FAILURE
Definition: Application.h:101
RoR::MSG_SIM_DELETE_ACTOR_REQUESTED
@ MSG_SIM_DELETE_ACTOR_REQUESTED
Payload = RoR::ActorPtr* (owner)
Definition: Application.h:123
RoR::Terrain::getGravity
float getGravity() const
Definition: Terrain.h:95
RoR::LT_AllBeam
@ LT_AllBeam
Definition: Application.h:320
RoR::MSG_APP_SCRIPT_THREAD_STATUS
@ MSG_APP_SCRIPT_THREAD_STATUS
Payload = RoR::ScriptEventArgs* (owner)
Definition: Application.h:94
RoR::ScriptEngine::functionExists
ScriptRetCode_t functionExists(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Checks if a global function exists.
Definition: ScriptEngine.cpp:568
RoR::MSG_EDI_MODIFY_GROUNDMODEL_REQUESTED
@ MSG_EDI_MODIFY_GROUNDMODEL_REQUESTED
Payload = RoR::ground_model_t* (weak)
Definition: Application.h:149
Terrain.h
RoR::GameContext::ShowLoaderGUI
void ShowLoaderGUI(int type, const Ogre::String &instance, const Ogre::String &box)
Definition: GameContext.cpp:660
BitMask_t
uint32_t BitMask_t
Definition: BitFlags.h:7
Ogre
Definition: ExtinguishableFireAffector.cpp:35
ScriptUtils.h
RoR::CurlTaskContext
Definition: CurlHelpers.h:34
RoR::Actor::ar_design_name
Ogre::String ar_design_name
Name of the vehicle/machine/object this actor represents.
Definition: Actor.h:350
RoR::MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED
@ MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:127
RoR::ActorManager::RepairActor
void RepairActor(Collisions *collisions, const Ogre::String &inst, const Ogre::String &box, bool keepPosition=false)
Definition: ActorManager.cpp:828
RoR::MSG_APP_UNLOAD_SCRIPT_REQUESTED
@ MSG_APP_UNLOAD_SCRIPT_REQUESTED
Payload = RoR::ScriptUnitId_t* (owner)
Definition: Application.h:93
RoR::ScriptUnitID_t
int ScriptUnitID_t
Unique sequentially generated ID of a loaded and running scriptin session. Use ScriptEngine::getScrip...
Definition: ForwardDeclarations.h:41
RoR::FreeForceRequest::ffr_id
int64_t ffr_id
Definition: SimData.h:790
RoR::ActorSpawnRequest::asr_position
Ogre::Vector3 asr_position
Definition: SimData.h:833
RoR::IWater::SetStaticWaterHeight
virtual void SetStaticWaterHeight(float value)=0
RoR::Actor::ar_filehash
std::string ar_filehash
Attribute; filled at spawn.
Definition: Actor.h:423
RoR::GUI::TopMenubar::ai_sectionconfig
Ogre::String ai_sectionconfig
Definition: GUI_TopMenubar.h:80
RoR::ActorManager::WakeUpAllActors
void WakeUpAllActors()
Definition: ActorManager.cpp:785
RoR::MSG_NET_CONNECT_PROGRESS
@ MSG_NET_CONNECT_PROGRESS
Definition: Application.h:99
Collisions.h
RoR::MSG_SIM_MODIFY_FREEFORCE_REQUESTED
@ MSG_SIM_MODIFY_FREEFORCE_REQUESTED
Payload = RoR::FreeForceRequest* (owner)
Definition: Application.h:134
RoR::ScriptUnit::scriptBuffer
Ogre::String scriptBuffer
Definition: ScriptEngine.h:85
RoR::ScriptUnit::scriptModule
AngelScript::asIScriptModule * scriptModule
Definition: ScriptEngine.h:77
RoR::GameContext::GetPlayerActor
const ActorPtr & GetPlayerActor()
Definition: GameContext.h:134
RoR::AI
@ AI
machine controlled by an Artificial Intelligence
Definition: SimData.h:97
RoR::ActorSpawnRequest::asr_instance_id
ActorInstanceID_t asr_instance_id
Optional; see ActorManager::GetActorNextInstanceID();.
Definition: SimData.h:829
ScriptRayQueryListener::queryResult
bool queryResult(SceneQuery::WorldFragment *fragment, Real distance) override
Definition: GameScript.cpp:1415
RoR::MSG_SIM_LOAD_SAVEGAME_REQUESTED
@ MSG_SIM_LOAD_SAVEGAME_REQUESTED
Definition: Application.h:119
RoR::Network::AddPacket
void AddPacket(int streamid, int type, int len, const char *content)
Definition: Network.cpp:612
RoR::ActorModifyRequest::amr_type
Type amr_type
Definition: SimData.h:872
RoR::ActorSpawnRequest::asr_rotation
Ogre::Quaternion asr_rotation
Definition: SimData.h:834
RoR::RaceSystem::SetRaceTimeDiff
void SetRaceTimeDiff(float diff)
Definition: RaceSystem.h:41
RoR::FreeForceRequest::ffr_type
int64_t ffr_type
Definition: SimData.h:791
RoR::TerrainEditorObject
Represents an instance of static terrain object (.ODEF file format)
Definition: TerrainEditor.h:35
RoR
Definition: AppContext.h:36
RoR::ScriptEngine::deleteFunction
ScriptRetCode_t deleteFunction(const Ogre::String &arg, const ScriptUnitID_t nid=SCRIPTUNITID_DEFAULT)
Deletes a global function from the script.
Definition: ScriptEngine.cpp:581
Network.h
RoR::ActorManager::GetActorById
const ActorPtr & GetActorById(ActorInstanceID_t actor_id)
Definition: ActorManager.cpp:1132
x
float x
Definition: (ValueTypes) quaternion.h:5
RoR::CurlTaskContext::ctc_msg_success
MsgType ctc_msg_success
Definition: CurlHelpers.h:40
RoR::ActorSpawnRequest::asr_enter
bool asr_enter
Definition: SimData.h:847
Water.h
RoR::App::GetGfxScene
GfxScene * GetGfxScene()
Definition: Application.cpp:279
RoR::GameContext::GetActorManager
ActorManager * GetActorManager()
Definition: GameContext.h:127
RoR::ActorModifyRequest::Type
Type
Definition: SimData.h:858
RoR::GameContext::FindActorByCollisionBox
ActorPtr FindActorByCollisionBox(std::string const &ev_src_instance_name, std::string const &box_name)
Definition: GameContext.cpp:605
RoR::LT_Train
@ LT_Train
Definition: Application.h:316
RoR::MSG_APP_SHUTDOWN_REQUESTED
@ MSG_APP_SHUTDOWN_REQUESTED
Definition: Application.h:85
RoR::GUI::TopMenubar::ai_distance
int ai_distance
Definition: GUI_TopMenubar.h:76
RoR::Terrain::getWater
IWater * getWater()
Definition: Terrain.h:83
RoR::TerrainGeometryManager::getTerrainGroup
Ogre::TerrainGroup * getTerrainGroup()
Definition: TerrainGeometryManager.h:46
RoR::Character::setRotation
void setRotation(Ogre::Radian rotation)
Definition: Character.cpp:98
RoR::FreeForceRequest::ffr_target_actor
int64_t ffr_target_actor
Definition: SimData.h:798
RoR::GameContext::GetTerrain
const TerrainPtr & GetTerrain()
Definition: GameContext.h:117