RigsofRods
Soft-body Physics Simulation
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
ActorManager.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 
25 
26 #include "ActorManager.h"
27 
28 #include "Application.h"
29 #include "Actor.h"
30 #include "CacheSystem.h"
31 #include "ContentManager.h"
32 #include "ChatSystem.h"
33 #include "Collisions.h"
34 #include "DashBoardManager.h"
35 #include "DynamicCollisions.h"
36 #include "Engine.h"
37 #include "GameContext.h"
38 #include "GfxScene.h"
39 #include "GUIManager.h"
40 #include "Console.h"
41 #include "GUI_TopMenubar.h"
42 #include "InputEngine.h"
43 #include "Language.h"
44 #include "MovableText.h"
45 #include "Network.h"
46 #include "PointColDetector.h"
47 #include "Replay.h"
48 #include "RigDef_Validator.h"
49 #include "ActorSpawner.h"
50 #include "ScriptEngine.h"
51 #include "SoundScriptManager.h"
52 #include "Terrain.h"
53 #include "ThreadPool.h"
54 #include "TuneupFileFormat.h"
55 #include "Utils.h"
56 #include "VehicleAI.h"
57 
58 using namespace Ogre;
59 using namespace RoR;
60 
61 const ActorPtr ActorManager::ACTORPTR_NULL; // Dummy value to be returned as const reference.
62 
63 ActorManager::ActorManager()
64  : m_dt_remainder(0.0f)
65  , m_forced_awake(false)
66  , m_physics_steps(2000)
67  , m_simulation_speed(1.0f)
68 {
69  // Create worker thread (used for physics calculations)
70  m_sim_thread_pool = std::unique_ptr<ThreadPool>(new ThreadPool(1));
71 }
72 
74 {
75  this->SyncWithSimThread(); // Wait for sim task to finish
76 }
77 
79 {
81  {
82  rq.asr_instance_id = this->GetActorNextInstanceId();
83  }
84  ActorPtr actor = new Actor(rq.asr_instance_id, static_cast<int>(m_actors.size()), def, rq);
85 
87  {
88  actor->sendStreamSetup();
89  }
90 
91  LOG(" == Spawning vehicle: " + def->name);
92 
93  ActorSpawner spawner;
94  spawner.ConfigureSections(actor->m_section_config, def);
96  spawner.ConfigureAssetPacks(actor, def);
97  spawner.ProcessNewActor(actor, rq, def);
98 
99  if (App::diag_actor_dump->getBool())
100  {
101  actor->WriteDiagnosticDump(actor->ar_filename + "_dump_raw.txt"); // Saves file to 'logs'
102  }
103 
104  /* POST-PROCESSING */
105 
106  actor->ar_initial_node_positions.resize(actor->ar_num_nodes);
107  actor->ar_initial_beam_defaults.resize(actor->ar_num_beams);
108  actor->ar_initial_node_masses.resize(actor->ar_num_nodes);
109 
110  actor->UpdateBoundingBoxes(); // (records the unrotated dimensions for 'veh_aab_size')
111 
112  // Apply spawn position & spawn rotation
113  for (int i = 0; i < actor->ar_num_nodes; i++)
114  {
115  actor->ar_nodes[i].AbsPosition = rq.asr_position + rq.asr_rotation * (actor->ar_nodes[i].AbsPosition - rq.asr_position);
116  actor->ar_nodes[i].RelPosition = actor->ar_nodes[i].AbsPosition - actor->ar_origin;
117  };
118 
119  /* Place correctly */
120  if (spawner.GetMemoryRequirements().num_fixes == 0)
121  {
122  Ogre::Vector3 vehicle_position = rq.asr_position;
123 
124  // check if over-sized
125  actor->UpdateBoundingBoxes();
126  vehicle_position.x += vehicle_position.x - actor->ar_bounding_box.getCenter().x;
127  vehicle_position.z += vehicle_position.z - actor->ar_bounding_box.getCenter().z;
128 
129  float miny = 0.0f;
130 
131  if (!actor->m_preloaded_with_terrain)
132  {
133  miny = vehicle_position.y;
134  }
135 
136  if (rq.asr_spawnbox != nullptr)
137  {
138  miny = rq.asr_spawnbox->relo.y + rq.asr_spawnbox->center.y;
139  }
140 
141  if (rq.asr_free_position)
142  actor->resetPosition(vehicle_position, true);
143  else
144  actor->resetPosition(vehicle_position.x, vehicle_position.z, true, miny);
145 
146  if (rq.asr_spawnbox != nullptr)
147  {
148  bool inside = true;
149 
150  for (int i = 0; i < actor->ar_num_nodes; i++)
151  inside = (inside && App::GetGameContext()->GetTerrain()->GetCollisions()->isInside(actor->ar_nodes[i].AbsPosition, rq.asr_spawnbox, 0.2f));
152 
153  if (!inside)
154  {
155  Vector3 gpos = Vector3(vehicle_position.x, 0.0f, vehicle_position.z);
156 
157  gpos -= rq.asr_rotation * Vector3((rq.asr_spawnbox->hi.x - rq.asr_spawnbox->lo.x + actor->ar_bounding_box.getMaximum().x - actor->ar_bounding_box.getMinimum().x) * 0.6f, 0.0f, 0.0f);
158 
159  actor->resetPosition(gpos.x, gpos.z, true, miny);
160  }
161  }
162  }
163  else
164  {
165  actor->resetPosition(rq.asr_position, true);
166  }
167  actor->UpdateBoundingBoxes();
168 
169  //compute final mass
170  actor->RecalculateNodeMasses(actor->m_dry_mass);
171  actor->ar_initial_total_mass = actor->m_total_mass;
172  for (int i = 0; i < actor->ar_num_nodes; i++)
173  {
174  actor->ar_initial_node_masses[i] = actor->ar_nodes[i].mass;
175  }
176 
177  //setup default sounds
178  if (!actor->m_disable_default_sounds)
179  {
181  }
182 
183  //compute node connectivity graph
184  actor->calcNodeConnectivityGraph();
185 
186  actor->UpdateBoundingBoxes();
187  actor->calculateAveragePosition();
188 
189  // calculate minimum camera radius
190  actor->calculateAveragePosition();
191  for (int i = 0; i < actor->ar_num_nodes; i++)
192  {
193  Real dist = actor->ar_nodes[i].AbsPosition.squaredDistance(actor->m_avg_node_position);
194  if (dist > actor->m_min_camera_radius)
195  {
196  actor->m_min_camera_radius = dist;
197  }
198  }
199  actor->m_min_camera_radius = std::sqrt(actor->m_min_camera_radius) * 1.2f; // twenty percent buffer
200 
201  // fix up submesh collision model
202  std::string subMeshGroundModelName = spawner.GetSubmeshGroundmodelName();
203  if (!subMeshGroundModelName.empty())
204  {
206  if (!actor->ar_submesh_ground_model)
207  {
209  }
210  }
211 
212  // Set beam defaults
213  for (int i = 0; i < actor->ar_num_beams; i++)
214  {
215  actor->ar_beams[i].initial_beam_strength = actor->ar_beams[i].strength;
217  actor->ar_initial_beam_defaults[i] = std::make_pair(actor->ar_beams[i].k, actor->ar_beams[i].d);
218  }
219 
220  actor->m_spawn_rotation = actor->getRotation();
221 
223 
224  actor->NotifyActorCameraChanged(); // setup sounds properly
225 
226  // calculate the number of wheel nodes
227  actor->m_wheel_node_count = 0;
228  for (int i = 0; i < actor->ar_num_nodes; i++)
229  {
230  if (actor->ar_nodes[i].nd_tyre_node)
231  actor->m_wheel_node_count++;
232  }
233 
234  // search m_net_first_wheel_node
235  actor->m_net_first_wheel_node = actor->ar_num_nodes;
236  for (int i = 0; i < actor->ar_num_nodes; i++)
237  {
238  if (actor->ar_nodes[i].nd_tyre_node || actor->ar_nodes[i].nd_rim_node)
239  {
240  actor->m_net_first_wheel_node = i;
241  break;
242  }
243  }
244 
245  // Initialize visuals
246  actor->updateVisual();
248 
249  // perform full visual update only if the vehicle won't be immediately driven by player.
250  if (actor->isPreloadedWithTerrain() || // .tobj file - Spawned sleeping somewhere on terrain
251  rq.asr_origin == ActorSpawnRequest::Origin::CONFIG_FILE || // RoR.cfg or commandline - not entered by default
252  actor->ar_num_cinecams == 0) // Not intended for player-controlling
253  {
254  actor->GetGfxActor()->UpdateSimDataBuffer(); // Initial fill of sim data buffers
255 
256  actor->GetGfxActor()->UpdateFlexbodies(); // Push tasks to threadpool
257  actor->GetGfxActor()->UpdateWheelVisuals(); // Push tasks to threadpool
258  actor->GetGfxActor()->UpdateCabMesh();
259  actor->GetGfxActor()->UpdateWingMeshes();
260  actor->GetGfxActor()->UpdateProps(0.f, false);
261  actor->GetGfxActor()->UpdateRods(); // beam visuals
262  actor->GetGfxActor()->FinishWheelUpdates(); // Sync tasks from threadpool
263  actor->GetGfxActor()->FinishFlexbodyTasks(); // Sync tasks from threadpool
264  }
265 
267 
268  if (actor->ar_engine)
269  {
271  actor->ar_engine->startEngine();
272  else
273  actor->ar_engine->offStart();
274  }
275  // pressurize tires
276  if (actor->getTyrePressure().IsEnabled())
277  {
278  actor->getTyrePressure().ModifyTyrePressure(0.f); // Initialize springiness of pressure-beams.
279  }
280 
282 
283  if (App::mp_state->getEnum<MpState>() == RoR::MpState::CONNECTED)
284  {
285  // network buffer layout (without RoRnet::VehicleState):
286  // -----------------------------------------------------
287 
288  // - 3 floats (x,y,z) for the reference node 0
289  // - ar_num_nodes - 1 times 3 short ints (compressed position info)
290  actor->m_net_node_buf_size = sizeof(float) * 3 + (actor->m_net_first_wheel_node - 1) * sizeof(short int) * 3;
292  // - ar_num_wheels times a float for the wheel rotation
293  actor->m_net_wheel_buf_size = actor->ar_num_wheels * sizeof(float);
295  // - bit array (made of ints) for the prop animation key states
297  (actor->m_prop_anim_key_states.size() / 8) + // whole chars
298  (size_t)(actor->m_prop_anim_key_states.size() % 8 != 0); // remainder: 0 or 1 chars
300 
302  {
304  if (actor->ar_engine)
305  {
306  actor->ar_engine->startEngine();
307  }
308  }
309 
310  actor->m_net_username = rq.asr_net_username;
311  actor->m_net_color_num = rq.asr_net_color;
312  }
313  else if (App::sim_replay_enabled->getBool())
314  {
315  actor->m_replay_handler = new Replay(actor, App::sim_replay_length->getInt());
316  }
317 
318  // Launch scripts (FIXME: ignores sectionconfig)
319  for (RigDef::Script const& script_def : def->root_module->scripts)
320  {
322  }
323 
324  LOG(" ===== DONE LOADING VEHICLE");
325 
326  if (App::diag_actor_dump->getBool())
327  {
328  actor->WriteDiagnosticDump(actor->ar_filename + "_dump_recalc.txt"); // Saves file to 'logs'
329  }
330 
331  m_actors.push_back(ActorPtr(actor));
332 
333  return actor;
334 }
335 
337 {
338  m_stream_mismatches.erase(sourceid);
339 
340  for (ActorPtr& actor : m_actors)
341  {
342  if (actor->ar_state != ActorState::NETWORKED_OK)
343  continue;
344 
345  if (actor->ar_net_source_id == sourceid)
346  {
348  }
349  }
350 }
351 
352 #ifdef USE_SOCKETW
353 void ActorManager::HandleActorStreamData(std::vector<RoR::NetRecvPacket> packet_buffer)
354 {
355  // Sort by stream source
356  std::stable_sort(packet_buffer.begin(), packet_buffer.end(),
357  [](const RoR::NetRecvPacket& a, const RoR::NetRecvPacket& b)
358  { return a.header.source > b.header.source; });
359  // Compress data stream by eliminating all but the last update from every consecutive group of stream data updates
360  auto it = std::unique(packet_buffer.rbegin(), packet_buffer.rend(),
361  [](const RoR::NetRecvPacket& a, const RoR::NetRecvPacket& b)
362  { return !memcmp(&a.header, &b.header, sizeof(RoRnet::Header)) &&
363  a.header.command == RoRnet::MSG2_STREAM_DATA; });
364  packet_buffer.erase(packet_buffer.begin(), it.base());
365  for (auto& packet : packet_buffer)
366  {
367  if (packet.header.command == RoRnet::MSG2_STREAM_REGISTER)
368  {
369  RoRnet::StreamRegister* reg = (RoRnet::StreamRegister *)packet.buffer;
370  if (reg->type == 0)
371  {
372  reg->name[127] = 0;
373  // NOTE: The filename is by default in "Bundle-qualified" format, i.e. "mybundle.zip:myactor.truck"
374  std::string filename_maybe_bundlequalified = SanitizeUtf8CString(reg->name);
375  std::string filename;
376  std::string bundlename;
377  SplitBundleQualifiedFilename(filename_maybe_bundlequalified, /*out:*/ bundlename, /*out:*/ filename);
378 
379  RoRnet::UserInfo info;
380  BitMask_t peeropts = BitMask_t(0);
381  if (!App::GetNetwork()->GetUserInfo(reg->origin_sourceid, info)
382  || !App::GetNetwork()->GetUserPeerOpts(reg->origin_sourceid, peeropts))
383  {
384  RoR::LogFormat("[RoR] Invalid STREAM_REGISTER, user id %d does not exist", reg->origin_sourceid);
385  reg->status = -1;
386  }
387  else if (filename.empty())
388  {
389  RoR::LogFormat("[RoR] Invalid STREAM_REGISTER (user '%s', ID %d), filename is empty string", info.username, reg->origin_sourceid);
390  reg->status = -1;
391  }
392  else
393  {
394  Str<200> text;
395  text << _L("spawned a new vehicle: ") << filename;
398 
399  LOG("[RoR] Creating remote actor for " + TOSTRING(reg->origin_sourceid) + ":" + TOSTRING(reg->origin_streamid));
400 
401  CacheEntryPtr actor_entry = App::GetCacheSystem()->FindEntryByFilename(LT_AllBeam, /*partial:*/false, filename_maybe_bundlequalified);
402 
403  if (!actor_entry)
404  {
407  _L("Mod not installed: ") + filename);
408  RoR::LogFormat("[RoR] Cannot create remote actor (not installed), filename: '%s'", filename_maybe_bundlequalified.c_str());
410  reg->status = -1;
411  }
412  else
413  {
414  auto actor_reg = reinterpret_cast<RoRnet::ActorStreamRegister*>(reg);
416  {
417  int offset = actor_reg->time - m_net_timer.getMilliseconds();
418  m_stream_time_offsets[reg->origin_sourceid] = offset - 100;
419  }
422  rq->asr_cache_entry = actor_entry;
423  if (strnlen(actor_reg->skin, 60) < 60 && actor_reg->skin[0] != '\0')
424  {
425  rq->asr_skin_entry = App::GetCacheSystem()->FetchSkinByName(actor_reg->skin); // FIXME: fetch skin by name+guid! ~ 03/2019
426  }
427  if (strnlen(actor_reg->sectionconfig, 60) < 60)
428  {
429  rq->asr_config = actor_reg->sectionconfig;
430  }
432  rq->asr_net_color = info.colournum;
433  rq->asr_net_peeropts = peeropts;
434  rq->net_source_id = reg->origin_sourceid;
435  rq->net_stream_id = reg->origin_streamid;
436 
438  MSG_SIM_SPAWN_ACTOR_REQUESTED, (void*)rq));
439 
440  reg->status = 1;
441  }
442  }
443 
445  }
446  }
447  else if (packet.header.command == RoRnet::MSG2_STREAM_REGISTER_RESULT)
448  {
449  RoRnet::StreamRegister* reg = (RoRnet::StreamRegister *)packet.buffer;
450  for (ActorPtr& actor: m_actors)
451  {
452  if (actor->ar_net_source_id == reg->origin_sourceid && actor->ar_net_stream_id == reg->origin_streamid)
453  {
454  int sourceid = packet.header.source;
455  actor->ar_net_stream_results[sourceid] = reg->status;
456 
457  String message = "";
458  switch (reg->status)
459  {
460  case 1: message = "successfully loaded stream"; break;
461  case -2: message = "detected mismatch stream"; break;
462  default: message = "could not load stream"; break;
463  }
464  LOG("Client " + TOSTRING(sourceid) + " " + message + " " + TOSTRING(reg->origin_streamid) +
465  " with name '" + reg->name + "', result code: " + TOSTRING(reg->status));
466  break;
467  }
468  }
469  }
470  else if (packet.header.command == RoRnet::MSG2_STREAM_UNREGISTER)
471  {
472  ActorPtr b = this->GetActorByNetworkLinks(packet.header.source, packet.header.streamid);
473  if (b)
474  {
476  {
478  }
479  }
480  m_stream_mismatches[packet.header.source].erase(packet.header.streamid);
481  }
482  else if (packet.header.command == RoRnet::MSG2_USER_LEAVE)
483  {
484  this->RemoveStreamSource(packet.header.source);
485  }
486  else if (packet.header.command == RoRnet::MSG2_STREAM_DATA)
487  {
488  for (ActorPtr& actor: m_actors)
489  {
490  if (actor->ar_state != ActorState::NETWORKED_OK)
491  continue;
492  if (packet.header.source == actor->ar_net_source_id && packet.header.streamid == actor->ar_net_stream_id)
493  {
494  actor->pushNetwork(packet.buffer, packet.header.size);
495  break;
496  }
497  }
498  }
499  }
500 }
501 #endif // USE_SOCKETW
502 
504 {
505  auto search = m_stream_time_offsets.find(sourceid);
506  if (search != m_stream_time_offsets.end())
507  {
508  return search->second;
509  }
510  return 0;
511 }
512 
513 void ActorManager::UpdateNetTimeOffset(int sourceid, int offset)
514 {
515  if (m_stream_time_offsets.find(sourceid) != m_stream_time_offsets.end())
516  {
517  m_stream_time_offsets[sourceid] += offset;
518  }
519 }
520 
522 {
523  if (!m_stream_mismatches[sourceid].empty())
524  return 0;
525 
526  for (ActorPtr& actor: m_actors)
527  {
528  if (actor->ar_state != ActorState::NETWORKED_OK)
529  continue;
530 
531  if (actor->ar_net_source_id == sourceid)
532  {
533  return 1;
534  }
535  }
536 
537  return 2;
538 }
539 
541 {
542  int result = 2;
543 
544  for (ActorPtr& actor: m_actors)
545  {
546  if (actor->ar_state == ActorState::NETWORKED_OK)
547  continue;
548 
549  int stream_result = actor->ar_net_stream_results[sourceid];
550  if (stream_result == -1 || stream_result == -2)
551  return 0;
552  if (stream_result == 1)
553  result = 1;
554  }
555 
556  return result;
557 }
558 
559 const ActorPtr& ActorManager::GetActorByNetworkLinks(int source_id, int stream_id)
560 {
561  for (ActorPtr& actor: m_actors)
562  {
563  if (actor->ar_net_source_id == source_id && actor->ar_net_stream_id == stream_id)
564  {
565  return actor;
566  }
567  }
568 
569  return ACTORPTR_NULL;
570 }
571 
573 {
574  if (m_actors[a]->ar_collision_bounding_boxes.empty() && m_actors[b]->ar_collision_bounding_boxes.empty())
575  {
576  return m_actors[a]->ar_bounding_box.intersects(m_actors[b]->ar_bounding_box);
577  }
578  else if (m_actors[a]->ar_collision_bounding_boxes.empty())
579  {
580  for (const auto& bbox_b : m_actors[b]->ar_collision_bounding_boxes)
581  if (bbox_b.intersects(m_actors[a]->ar_bounding_box))
582  return true;
583  }
584  else if (m_actors[b]->ar_collision_bounding_boxes.empty())
585  {
586  for (const auto& bbox_a : m_actors[a]->ar_collision_bounding_boxes)
587  if (bbox_a.intersects(m_actors[b]->ar_bounding_box))
588  return true;
589  }
590  else
591  {
592  for (const auto& bbox_a : m_actors[a]->ar_collision_bounding_boxes)
593  for (const auto& bbox_b : m_actors[b]->ar_collision_bounding_boxes)
594  if (bbox_a.intersects(bbox_b))
595  return true;
596  }
597 
598  return false;
599 }
600 
602 {
603  if (m_actors[a]->ar_predicted_coll_bounding_boxes.empty() && m_actors[b]->ar_predicted_coll_bounding_boxes.empty())
604  {
605  return m_actors[a]->ar_predicted_bounding_box.intersects(m_actors[b]->ar_predicted_bounding_box);
606  }
607  else if (m_actors[a]->ar_predicted_coll_bounding_boxes.empty())
608  {
609  for (const auto& bbox_b : m_actors[b]->ar_predicted_coll_bounding_boxes)
610  if (bbox_b.intersects(m_actors[a]->ar_predicted_bounding_box))
611  return true;
612  }
613  else if (m_actors[b]->ar_predicted_coll_bounding_boxes.empty())
614  {
615  for (const auto& bbox_a : m_actors[a]->ar_predicted_coll_bounding_boxes)
616  if (bbox_a.intersects(m_actors[b]->ar_predicted_bounding_box))
617  return true;
618  }
619  else
620  {
621  for (const auto& bbox_a : m_actors[a]->ar_predicted_coll_bounding_boxes)
622  for (const auto& bbox_b : m_actors[b]->ar_predicted_coll_bounding_boxes)
623  if (bbox_a.intersects(bbox_b))
624  return true;
625  }
626 
627  return false;
628 }
629 
630 void ActorManager::RecursiveActivation(int j, std::vector<bool>& visited)
631 {
632  if (visited[j] || m_actors[j]->ar_state != ActorState::LOCAL_SIMULATED)
633  return;
634 
635  visited[j] = true;
636 
637  for (unsigned int t = 0; t < m_actors.size(); t++)
638  {
639  if (t == j || visited[t])
640  continue;
642  {
643  m_actors[t]->ar_sleep_counter = 0.0f;
644  this->RecursiveActivation(t, visited);
645  }
647  {
648  m_actors[t]->ar_sleep_counter = 0.0f;
649  m_actors[t]->ar_state = ActorState::LOCAL_SIMULATED;
650  this->RecursiveActivation(t, visited);
651  }
652  }
653 }
654 
656 {
657  if (source_actor->ar_forward_commands)
658  {
659  auto linked_actors = source_actor->ar_linked_actors;
660 
661  for (ActorPtr& actor : this->GetActors())
662  {
663  if (actor != source_actor && actor->ar_import_commands &&
664  (actor->getPosition().distance(source_actor->getPosition()) <
665  actor->m_min_camera_radius + source_actor->m_min_camera_radius))
666  {
667  // activate the truck
668  if (actor->ar_state == ActorState::LOCAL_SLEEPING)
669  {
670  actor->ar_sleep_counter = 0.0f;
671  actor->ar_state = ActorState::LOCAL_SIMULATED;
672  }
673 
674  if (App::sim_realistic_commands->getBool())
675  {
676  if (std::find(linked_actors.begin(), linked_actors.end(), actor) == linked_actors.end())
677  continue;
678  }
679 
680  // forward commands
681  for (int j = 1; j <= MAX_COMMANDS; j++) // BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
682  {
683  actor->ar_command_key[j].playerInputValue = std::max(source_actor->ar_command_key[j].playerInputValue,
684  source_actor->ar_command_key[j].commandValue);
685  }
686  if (source_actor->ar_toggle_ties)
687  {
688  //actor->tieToggle();
691  rq->alr_actor_instance_id = actor->ar_instance_id;
692  rq->alr_tie_group = -1;
694 
695  }
696  if (source_actor->ar_toggle_ropes)
697  {
698  //actor->ropeToggle(-1);
701  rq->alr_actor_instance_id = actor->ar_instance_id;
702  rq->alr_rope_group = -1;
704  }
705  }
706  }
707  // just send brake and lights to the connected trucks, and no one else :)
708  for (auto hook : source_actor->ar_hooks)
709  {
710  if (!hook.hk_locked_actor || hook.hk_locked_actor == source_actor)
711  continue;
712 
713  // forward brakes
714  hook.hk_locked_actor->ar_brake = source_actor->ar_brake;
715  if (hook.hk_locked_actor->ar_parking_brake != source_actor->ar_trailer_parking_brake)
716  {
717  hook.hk_locked_actor->parkingbrakeToggle();
718  }
719 
720  // forward lights
721  hook.hk_locked_actor->importLightStateMask(source_actor->getLightStateMask());
722  }
723  }
724 }
725 
727 {
728  for (auto& entry: inter_actor_links)
729  {
730  auto& actor_pair = entry.second;
731  if ((actor_pair.first == a1 && actor_pair.second == a2) ||
732  (actor_pair.first == a2 && actor_pair.second == a1))
733  {
734  return true;
735  }
736  }
737  return false;
738 }
739 
740 void ActorManager::UpdateSleepingState(ActorPtr player_actor, float dt)
741 {
742  if (!m_forced_awake)
743  {
744  for (ActorPtr& actor: m_actors)
745  {
746  if (actor->ar_state != ActorState::LOCAL_SIMULATED)
747  continue;
748  if (actor->ar_driveable == AI)
749  continue;
750  if (actor->getVelocity().squaredLength() > 0.01f)
751  {
752  actor->ar_sleep_counter = 0.0f;
753  continue;
754  }
755 
756  actor->ar_sleep_counter += dt;
757 
758  if (actor->ar_sleep_counter >= 10.0f)
759  {
760  actor->ar_state = ActorState::LOCAL_SLEEPING;
761  }
762  }
763  }
764 
765  if (player_actor && player_actor->ar_state == ActorState::LOCAL_SLEEPING)
766  {
767  player_actor->ar_state = ActorState::LOCAL_SIMULATED;
768  }
769 
770  std::vector<bool> visited(m_actors.size());
771  // Recursivly activate all actors which can be reached from current actor
772  if (player_actor && player_actor->ar_state == ActorState::LOCAL_SIMULATED)
773  {
774  player_actor->ar_sleep_counter = 0.0f;
775  this->RecursiveActivation(player_actor->ar_vector_index, visited);
776  }
777  // Snowball effect (activate all actors which might soon get hit by a moving actor)
778  for (unsigned int t = 0; t < m_actors.size(); t++)
779  {
780  if (m_actors[t]->ar_state == ActorState::LOCAL_SIMULATED && m_actors[t]->ar_sleep_counter == 0.0f)
781  this->RecursiveActivation(t, visited);
782  }
783 }
784 
786 {
787  for (ActorPtr& actor: m_actors)
788  {
789  if (actor->ar_state == ActorState::LOCAL_SLEEPING)
790  {
791  actor->ar_state = ActorState::LOCAL_SIMULATED;
792  actor->ar_sleep_counter = 0.0f;
793  }
794  }
795 }
796 
798 {
799  m_forced_awake = false;
800  for (ActorPtr& actor: m_actors)
801  {
802  if (actor->ar_state == ActorState::LOCAL_SIMULATED)
803  {
804  actor->ar_state = ActorState::LOCAL_SLEEPING;
805  }
806  }
807 }
808 
809 ActorPtr ActorManager::FindActorInsideBox(Collisions* collisions, const Ogre::String& inst, const Ogre::String& box)
810 {
811  // try to find the desired actor (the one in the box)
812  ActorPtr ret = nullptr;
813  for (ActorPtr& actor: m_actors)
814  {
815  if (collisions->isInside(actor->ar_nodes[0].AbsPosition, inst, box))
816  {
817  if (ret == nullptr)
818  // first actor found
819  ret = actor;
820  else
821  // second actor found -> unclear which one was meant
822  return nullptr;
823  }
824  }
825  return ret;
826 }
827 
828 void ActorManager::RepairActor(Collisions* collisions, const Ogre::String& inst, const Ogre::String& box, bool keepPosition)
829 {
830  ActorPtr actor = this->FindActorInsideBox(collisions, inst, box);
831  if (actor != nullptr)
832  {
834 
836  rq->amr_actor = actor->ar_instance_id;
839  }
840 }
841 
842 std::pair<ActorPtr, float> ActorManager::GetNearestActor(Vector3 position)
843 {
844  ActorPtr nearest_actor = nullptr;
845  float min_squared_distance = std::numeric_limits<float>::max();
846  for (ActorPtr& actor : m_actors)
847  {
848  float squared_distance = position.squaredDistance(actor->ar_nodes[0].AbsPosition);
849  if (squared_distance < min_squared_distance)
850  {
851  min_squared_distance = squared_distance;
852  nearest_actor = actor;
853  }
854  }
855  return std::make_pair(nearest_actor, std::sqrt(min_squared_distance));
856 }
857 
858 void ActorManager::CleanUpSimulation() // Called after simulation finishes
859 {
860  while (m_actors.size() > 0)
861  {
862  this->DeleteActorInternal(m_actors.back()); // OK to invoke here - CleanUpSimulation() - processing `MSG_SIM_UNLOAD_TERRAIN_REQUESTED`
863  }
864 
865  m_total_sim_time = 0.f;
867  m_simulation_paused = false;
868  m_simulation_speed = 1.f;
869 }
870 
872 {
873  if (actor == nullptr || actor->ar_state == ActorState::DISPOSED)
874  return;
875 
876  this->SyncWithSimThread();
877 
878 #ifdef USE_SOCKETW
879  if (App::mp_state->getEnum<MpState>() == RoR::MpState::CONNECTED)
880  {
881  if (actor->ar_state != ActorState::NETWORKED_OK)
882  {
884  }
885  else if (std::count_if(m_actors.begin(), m_actors.end(), [actor](ActorPtr& b)
886  { return b->ar_net_source_id == actor->ar_net_source_id; }) == 1)
887  {
888  // We're deleting the last actor from this stream source, reset the stream time offset
890  }
891  }
892 #endif // USE_SOCKETW
893 
894  // Unload actor's scripts
895  std::vector<ScriptUnitID_t> unload_list;
896  for (auto& pair : App::GetScriptEngine()->getScriptUnits())
897  {
898  if (pair.second.associatedActor == actor)
899  unload_list.push_back(pair.first);
900  }
901  for (ScriptUnitID_t id : unload_list)
902  {
904  }
905 
906  // Remove FreeForces referencing this actor
907  m_free_forces.erase(
908  std::remove_if(
909  m_free_forces.begin(),
910  m_free_forces.end(),
911  [actor](FreeForce& item) { return item.ffc_base_actor == actor || item.ffc_target_actor == actor; }),
912  m_free_forces.end());
913 
914  // Only dispose(), do not `delete`; a script may still hold pointer to the object.
915  actor->dispose();
916 
917  EraseIf(m_actors, [actor](ActorPtr& curActor) { return actor == curActor; });
918 
919  // Upate actor indices
920  for (unsigned int i = 0; i < m_actors.size(); i++)
921  m_actors[i]->ar_vector_index = i;
922 }
923 
924 // ACTORLIST for cycling with hotkeys
925 // ----------------------------------
926 
927 int FindPivotActorId(ActorPtr player, ActorPtr prev_player)
928 {
929  if (player != nullptr)
930  return player->ar_vector_index;
931  else if (prev_player != nullptr)
932  return prev_player->ar_vector_index + 1;
933  return -1;
934 }
935 
937 {
938  bool retval = !actor->isPreloadedWithTerrain();
939 
940  // Exclude remote actors, if desired
941  if (!App::mp_cyclethru_net_actors->getBool())
942  {
944  {
945  retval = false;
946  }
947  }
948 
949  return retval;
950 }
951 
953 {
954  int pivot_index = FindPivotActorId(player, prev_player);
955 
956  for (int i = pivot_index + 1; i < m_actors.size(); i++)
957  {
959  return m_actors[i];
960  }
961 
962  for (int i = 0; i < pivot_index; i++)
963  {
965  return m_actors[i];
966  }
967 
968  if (pivot_index >= 0)
969  {
970  if (ShouldIncludeActorInList(m_actors[pivot_index]))
971  return m_actors[pivot_index];
972  }
973 
974  return ACTORPTR_NULL;
975 }
976 
978 {
979  int pivot_index = FindPivotActorId(player, prev_player);
980 
981  for (int i = pivot_index - 1; i >= 0; i--)
982  {
984  return m_actors[i];
985  }
986 
987  for (int i = static_cast<int>(m_actors.size()) - 1; i > pivot_index; i--)
988  {
990  return m_actors[i];
991  }
992 
993  if (pivot_index >= 0)
994  {
995  if (ShouldIncludeActorInList(m_actors[pivot_index]))
996  return m_actors[pivot_index];
997  }
998 
999  return ACTORPTR_NULL;
1000 }
1001 
1002 // END actorlist
1003 
1005 {
1006  for (ActorPtr& actor: m_actors)
1007  {
1008  if (actor->ar_rescuer_flag)
1009  {
1010  return actor;
1011  }
1012  }
1013  return ACTORPTR_NULL;
1014 }
1015 
1017 {
1018  float dt = m_simulation_time;
1019 
1020  // do not allow dt > 1/20
1021  dt = std::min(dt, 1.0f / 20.0f);
1022 
1023  dt *= m_simulation_speed;
1024 
1025  dt += m_dt_remainder;
1026  m_physics_steps = dt / PHYSICS_DT;
1027  if (m_physics_steps == 0)
1028  {
1029  return;
1030  }
1031 
1033  dt = PHYSICS_DT * m_physics_steps;
1034 
1035  this->SyncWithSimThread();
1036 
1037  this->UpdateSleepingState(player_actor, dt);
1038 
1039  for (ActorPtr& actor: m_actors)
1040  {
1041  actor->HandleInputEvents(dt);
1042  actor->HandleAngelScriptEvents(dt);
1043 
1044 #ifdef USE_ANGELSCRIPT
1045  if (actor->ar_vehicle_ai && actor->ar_vehicle_ai->isActive())
1046  actor->ar_vehicle_ai->update(dt, 0);
1047 #endif // USE_ANGELSCRIPT
1048 
1049  if (actor->ar_engine)
1050  {
1051  if (actor->ar_driveable == TRUCK)
1052  {
1053  this->UpdateTruckFeatures(actor, dt);
1054  }
1055  if (actor->ar_state == ActorState::LOCAL_SLEEPING)
1056  {
1057  actor->ar_engine->UpdateEngine(dt, 1);
1058  }
1059  actor->ar_engine->UpdateEngineAudio();
1060  }
1061 
1062  // Always update indicator states - used by 'u' type flares.
1063  actor->updateDashBoards(dt);
1064 
1065  // Blinkers (turn signals) must always be updated
1066  actor->updateFlareStates(dt);
1067 
1068  if (actor->ar_state != ActorState::LOCAL_SLEEPING)
1069  {
1070  actor->updateVisual(dt);
1071  if (actor->ar_update_physics && App::gfx_skidmarks_mode->getInt() > 0)
1072  {
1073  actor->updateSkidmarks();
1074  }
1075  }
1076  if (App::mp_state->getEnum<MpState>() == RoR::MpState::CONNECTED)
1077  {
1078  // FIXME: Hidden actors must also be updated to workaround a glitch, see https://github.com/RigsOfRods/rigs-of-rods/issues/2911
1079  if (actor->ar_state == ActorState::NETWORKED_OK || actor->ar_state == ActorState::NETWORKED_HIDDEN)
1080  actor->calcNetwork();
1081  else
1082  actor->sendStreamData();
1083  }
1084  }
1085 
1086  if (player_actor != nullptr)
1087  {
1088  this->ForwardCommands(player_actor);
1089  if (player_actor->ar_toggle_ties)
1090  {
1091  //player_actor->tieToggle();
1094  rq->alr_actor_instance_id = player_actor->ar_instance_id;
1095  rq->alr_tie_group = -1;
1097 
1098  player_actor->ar_toggle_ties = false;
1099  }
1100  if (player_actor->ar_toggle_ropes)
1101  {
1102  //player_actor->ropeToggle(-1);
1105  rq->alr_actor_instance_id = player_actor->ar_instance_id;
1106  rq->alr_rope_group = -1;
1108 
1109  player_actor->ar_toggle_ropes = false;
1110  }
1111 
1112  player_actor->ForceFeedbackStep(m_physics_steps);
1113 
1114  if (player_actor->ar_state == ActorState::LOCAL_REPLAY)
1115  {
1116  player_actor->getReplay()->replayStepActor();
1117  }
1118  }
1119 
1120  auto func = std::function<void()>([this]()
1121  {
1122  this->UpdatePhysicsSimulation();
1123  });
1124  m_sim_task = m_sim_thread_pool->RunTask(func);
1125 
1126  m_total_sim_time += dt;
1127 
1128  if (!App::app_async_physics->getBool())
1129  m_sim_task->join();
1130 }
1131 
1133 {
1134  for (ActorPtr& actor: m_actors)
1135  {
1136  if (actor->ar_instance_id == actor_id)
1137  {
1138  return actor;
1139  }
1140  }
1141  return ACTORPTR_NULL;
1142 }
1143 
1145 {
1146  for (ActorPtr& actor: m_actors)
1147  {
1148  actor->UpdatePhysicsOrigin();
1149  }
1150  for (int i = 0; i < m_physics_steps; i++)
1151  {
1152  {
1153  std::vector<std::function<void()>> tasks;
1154  for (ActorPtr& actor: m_actors)
1155  {
1156  if (actor->ar_update_physics = actor->CalcForcesEulerPrepare(i == 0))
1157  {
1158  auto func = std::function<void()>([this, i, &actor]()
1159  {
1160  actor->CalcForcesEulerCompute(i == 0, m_physics_steps);
1161  });
1162  tasks.push_back(func);
1163  }
1164  }
1165  App::GetThreadPool()->Parallelize(tasks);
1166  for (ActorPtr& actor: m_actors)
1167  {
1168  if (actor->ar_update_physics)
1169  {
1170  actor->CalcBeamsInterActor();
1171  }
1172  }
1173  }
1174  {
1175  std::vector<std::function<void()>> tasks;
1176  for (ActorPtr& actor: m_actors)
1177  {
1178  if (actor->m_inter_point_col_detector != nullptr && (actor->ar_update_physics ||
1179  (App::mp_pseudo_collisions->getBool() && actor->ar_state == ActorState::NETWORKED_OK)))
1180  {
1181  auto func = std::function<void()>([this, &actor]()
1182  {
1183  actor->m_inter_point_col_detector->UpdateInterPoint();
1184  if (actor->ar_collision_relevant)
1185  {
1186  ResolveInterActorCollisions(PHYSICS_DT,
1187  *actor->m_inter_point_col_detector,
1188  actor->ar_num_collcabs,
1189  actor->ar_collcabs,
1190  actor->ar_cabs,
1191  actor->ar_inter_collcabrate,
1192  actor->ar_nodes,
1193  actor->ar_collision_range,
1194  *actor->ar_submesh_ground_model);
1195  }
1196  });
1197  tasks.push_back(func);
1198  }
1199  }
1200  App::GetThreadPool()->Parallelize(tasks);
1201  }
1202 
1203  // Apply FreeForces - intentionally as a separate pass over all actors
1204  this->CalcFreeForces();
1205  }
1206  for (ActorPtr& actor: m_actors)
1207  {
1208  actor->m_ongoing_reset = false;
1209  if (actor->ar_update_physics && m_physics_steps > 0)
1210  {
1211  Vector3 camera_gforces = actor->m_camera_gforces_accu / m_physics_steps;
1212  actor->m_camera_gforces_accu = Vector3::ZERO;
1213  actor->m_camera_gforces = actor->m_camera_gforces * 0.5f + camera_gforces * 0.5f;
1214  actor->calculateLocalGForces();
1215  actor->calculateAveragePosition();
1216  actor->m_avg_node_velocity = actor->m_avg_node_position - actor->m_avg_node_position_prev;
1217  actor->m_avg_node_velocity /= (m_physics_steps * PHYSICS_DT);
1218  actor->m_avg_node_position_prev = actor->m_avg_node_position;
1219  actor->ar_top_speed = std::max(actor->ar_top_speed, actor->ar_nodes[0].Velocity.length());
1220  }
1221  }
1222 }
1223 
1225 {
1226  if (m_sim_task)
1227  m_sim_task->join();
1228 }
1229 
1230 void HandleErrorLoadingFile(std::string type, std::string filename, std::string exception_msg)
1231 {
1232  RoR::Str<200> msg;
1233  msg << "Failed to load '" << filename << "' (type: '" << type << "'), message: " << exception_msg;
1236 }
1237 
1238 void HandleErrorLoadingTruckfile(std::string filename, std::string exception_msg)
1239 {
1240  HandleErrorLoadingFile("actor", filename, exception_msg);
1241 }
1242 
1244 {
1245  // Check the actor exists in mod cache
1246  if (rq.asr_cache_entry == nullptr)
1247  {
1248  HandleErrorLoadingTruckfile(rq.asr_filename, "Truckfile not found in ModCache (probably not installed)");
1249  return nullptr;
1250  }
1251 
1252  // If already parsed, re-use
1253  if (rq.asr_cache_entry->actor_def != nullptr)
1254  {
1255  return rq.asr_cache_entry->actor_def;
1256  }
1257 
1258  // Load the 'truckfile'
1259  try
1260  {
1262  Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(rq.asr_cache_entry->fname, rq.asr_cache_entry->resource_group);
1263 
1264  if (stream.isNull() || !stream->isReadable())
1265  {
1266  HandleErrorLoadingTruckfile(rq.asr_cache_entry->fname, "Unable to open/read truckfile");
1267  return nullptr;
1268  }
1269 
1270  RoR::LogFormat("[RoR] Parsing truckfile '%s'", rq.asr_cache_entry->fname.c_str());
1271  RigDef::Parser parser;
1272  parser.Prepare();
1273  parser.ProcessOgreStream(stream.getPointer(), rq.asr_cache_entry->resource_group);
1274  parser.Finalize();
1275 
1276  auto def = parser.GetFile();
1277 
1278  // VALIDATING
1279  LOG(" == Validating vehicle: " + def->name);
1280 
1281  RigDef::Validator validator;
1282  validator.Setup(def);
1283 
1285  {
1286  // Workaround: Some terrains pre-load truckfiles with special purpose:
1287  // "soundloads" = play sound effect at certain spot
1288  // "fixes" = structures of N/B fixed to the ground
1289  // These files can have no beams. Possible extensions: .load or .fixed
1290  std::string file_extension = rq.asr_cache_entry->fname.substr(rq.asr_cache_entry->fname.find_last_of('.'));
1291  Ogre::StringUtil::toLowerCase(file_extension);
1292  if ((file_extension == ".load") || (file_extension == ".fixed"))
1293  {
1294  validator.SetCheckBeams(false);
1295  }
1296  }
1297 
1298  validator.Validate(); // Sends messages to console
1299 
1300  def->hash = Sha1Hash(stream->getAsString());
1301 
1302  rq.asr_cache_entry->actor_def = def;
1303  return def;
1304  }
1305  catch (Ogre::Exception& oex)
1306  {
1307  HandleErrorLoadingTruckfile(rq.asr_cache_entry->fname, oex.getDescription().c_str());
1308  return nullptr;
1309  }
1310  catch (std::exception& stex)
1311  {
1313  return nullptr;
1314  }
1315  catch (...)
1316  {
1317  HandleErrorLoadingTruckfile(rq.asr_cache_entry->fname, "<Unknown exception occurred>");
1318  return nullptr;
1319  }
1320 }
1321 
1322 std::vector<ActorPtr> ActorManager::GetLocalActors()
1323 {
1324  std::vector<ActorPtr> actors;
1325  for (ActorPtr& actor: m_actors)
1326  {
1327  if (actor->ar_state != ActorState::NETWORKED_OK)
1328  actors.push_back(actor);
1329  }
1330  return actors;
1331 }
1332 
1334 {
1335  // Simulation pace adjustment (slowmotion)
1336  if (!App::GetGameContext()->GetRaceSystem().IsRaceInProgress())
1337  {
1338  // EV_COMMON_ACCELERATE_SIMULATION
1339  if (App::GetInputEngine()->getEventBoolValue(EV_COMMON_ACCELERATE_SIMULATION))
1340  {
1341  float simulation_speed = this->GetSimulationSpeed() * pow(2.0f, dt / 2.0f);
1342  this->SetSimulationSpeed(simulation_speed);
1343  String ssmsg = _L("New simulation speed: ") + TOSTRING(Round(simulation_speed * 100.0f, 1)) + "%";
1345  }
1346 
1347  // EV_COMMON_DECELERATE_SIMULATION
1348  if (App::GetInputEngine()->getEventBoolValue(EV_COMMON_DECELERATE_SIMULATION))
1349  {
1350  float simulation_speed = this->GetSimulationSpeed() * pow(0.5f, dt / 2.0f);
1351  this->SetSimulationSpeed(simulation_speed);
1352  String ssmsg = _L("New simulation speed: ") + TOSTRING(Round(simulation_speed * 100.0f, 1)) + "%";
1354  }
1355 
1356  // EV_COMMON_RESET_SIMULATION_PACE
1357  if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_RESET_SIMULATION_PACE))
1358  {
1359  float simulation_speed = this->GetSimulationSpeed();
1360  if (simulation_speed != 1.0f)
1361  {
1362  m_last_simulation_speed = simulation_speed;
1363  this->SetSimulationSpeed(1.0f);
1364  UTFString ssmsg = _L("Simulation speed reset.");
1366  }
1367  else if (m_last_simulation_speed != 1.0f)
1368  {
1370  String ssmsg = _L("New simulation speed: ") + TOSTRING(Round(m_last_simulation_speed * 100.0f, 1)) + "%";
1372  }
1373  }
1374 
1375  // Special adjustment while racing
1376  if (App::GetGameContext()->GetRaceSystem().IsRaceInProgress() && this->GetSimulationSpeed() != 1.0f)
1377  {
1379  this->SetSimulationSpeed(1.f);
1380  }
1381  }
1382 
1383  // EV_COMMON_TOGGLE_PHYSICS - Freeze/unfreeze physics
1384  if (App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_TOGGLE_PHYSICS))
1385  {
1387 
1388  if (m_simulation_paused)
1389  {
1390  String ssmsg = _L("Physics paused");
1392  }
1393  else
1394  {
1395  String ssmsg = _L("Physics unpaused");
1397  }
1398  }
1399 
1400  // Calculate simulation time
1401  if (m_simulation_paused)
1402  {
1403  m_simulation_time = 0.f;
1404 
1405  // Frozen physics stepping
1406  if (this->GetSimulationSpeed() > 0.0f)
1407  {
1408  // EV_COMMON_REPLAY_FAST_FORWARD - Advance simulation while pressed
1409  // EV_COMMON_REPLAY_FORWARD - Advanced simulation one step
1410  if (App::GetInputEngine()->getEventBoolValue(EV_COMMON_REPLAY_FAST_FORWARD) ||
1411  App::GetInputEngine()->getEventBoolValueBounce(EV_COMMON_REPLAY_FORWARD))
1412  {
1414  }
1415  }
1416  }
1417  else
1418  {
1419  m_simulation_time = dt;
1420  }
1421 }
1422 
1424 {
1425  if (vehicle->isBeingReset() || vehicle->ar_physics_paused)
1426  return;
1427 #ifdef USE_ANGELSCRIPT
1428  if (vehicle->ar_vehicle_ai && vehicle->ar_vehicle_ai->isActive())
1429  return;
1430 #endif // USE_ANGELSCRIPT
1431 
1432  EnginePtr engine = vehicle->ar_engine;
1433 
1434  if (engine && engine->hasContact() &&
1435  engine->getAutoMode() == SimGearboxMode::AUTO &&
1436  engine->getAutoShift() != Engine::NEUTRAL)
1437  {
1438  Ogre::Vector3 dirDiff = vehicle->getDirection();
1439  Ogre::Degree pitchAngle = Ogre::Radian(asin(dirDiff.dotProduct(Ogre::Vector3::UNIT_Y)));
1440 
1441  if (std::abs(pitchAngle.valueDegrees()) > 2.0f)
1442  {
1443  if (engine->getAutoShift() > Engine::NEUTRAL && vehicle->ar_avg_wheel_speed < +0.02f && pitchAngle.valueDegrees() > 0.0f ||
1444  engine->getAutoShift() < Engine::NEUTRAL && vehicle->ar_avg_wheel_speed > -0.02f && pitchAngle.valueDegrees() < 0.0f)
1445  {
1446  // anti roll back in SimGearboxMode::AUTO (DRIVE, TWO, ONE) mode
1447  // anti roll forth in SimGearboxMode::AUTO (REAR) mode
1448  float g = std::abs(App::GetGameContext()->GetTerrain()->getGravity());
1449  float downhill_force = std::abs(sin(pitchAngle.valueRadians()) * vehicle->getTotalMass()) * g;
1450  float engine_force = std::abs(engine->getTorque()) / vehicle->getAvgPropedWheelRadius();
1451  float ratio = std::max(0.0f, 1.0f - (engine_force / downhill_force));
1452  if (vehicle->ar_avg_wheel_speed * pitchAngle.valueDegrees() > 0.0f)
1453  {
1454  ratio *= sqrt((0.02f - vehicle->ar_avg_wheel_speed) / 0.02f);
1455  }
1456  vehicle->ar_brake = sqrt(ratio);
1457  }
1458  }
1459  else if (vehicle->ar_brake == 0.0f && !vehicle->ar_parking_brake && engine->getTorque() == 0.0f)
1460  {
1461  float ratio = std::max(0.0f, 0.2f - std::abs(vehicle->ar_avg_wheel_speed)) / 0.2f;
1462  vehicle->ar_brake = ratio;
1463  }
1464  }
1465 
1466  if (vehicle->cc_mode)
1467  {
1468  vehicle->UpdateCruiseControl(dt);
1469  }
1470  if (vehicle->sl_enabled)
1471  {
1472  // check speed limit
1473  if (engine && engine->getGear() != 0)
1474  {
1475  float accl = (vehicle->sl_speed_limit - std::abs(vehicle->ar_wheel_speed / 1.02f)) * 2.0f;
1476  engine->setAcc(Ogre::Math::Clamp(accl, 0.0f, engine->getAcc()));
1477  }
1478  }
1479 
1480  BITMASK_SET(vehicle->m_lightmask, RoRnet::LIGHTMASK_BRAKES, (vehicle->ar_brake > 0.01f && !vehicle->ar_parking_brake));
1481  BITMASK_SET(vehicle->m_lightmask, RoRnet::LIGHTMASK_REVERSE, (vehicle->ar_engine && vehicle->ar_engine->getGear() < 0));
1482 }
1483 
1485 {
1486  for (FreeForce& freeforce: m_free_forces)
1487  {
1488  // Sanity checks
1489  ROR_ASSERT(freeforce.ffc_base_actor != nullptr);
1490  ROR_ASSERT(freeforce.ffc_base_actor->ar_state != ActorState::DISPOSED);
1491  ROR_ASSERT(freeforce.ffc_base_node != NODENUM_INVALID);
1492  ROR_ASSERT(freeforce.ffc_base_node <= freeforce.ffc_base_actor->ar_num_nodes);
1493 
1494 
1495  switch (freeforce.ffc_type)
1496  {
1498  freeforce.ffc_base_actor->ar_nodes[freeforce.ffc_base_node].Forces += freeforce.ffc_force_magnitude * freeforce.ffc_force_const_direction;
1499  break;
1500 
1502  {
1503  const Vector3 force_direction = (freeforce.ffc_target_coords - freeforce.ffc_base_actor->ar_nodes[freeforce.ffc_base_node].AbsPosition).normalisedCopy();
1504  freeforce.ffc_base_actor->ar_nodes[freeforce.ffc_base_node].Forces += freeforce.ffc_force_magnitude * force_direction;
1505  }
1506  break;
1507 
1509  {
1510  // Sanity checks
1511  ROR_ASSERT(freeforce.ffc_target_actor != nullptr);
1512  ROR_ASSERT(freeforce.ffc_target_actor->ar_state != ActorState::DISPOSED);
1513  ROR_ASSERT(freeforce.ffc_target_node != NODENUM_INVALID);
1514  ROR_ASSERT(freeforce.ffc_target_node <= freeforce.ffc_target_actor->ar_num_nodes);
1515 
1516  const Vector3 force_direction = (freeforce.ffc_target_actor->ar_nodes[freeforce.ffc_target_node].AbsPosition - freeforce.ffc_base_actor->ar_nodes[freeforce.ffc_base_node].AbsPosition).normalisedCopy();
1517  freeforce.ffc_base_actor->ar_nodes[freeforce.ffc_base_node].Forces += freeforce.ffc_force_magnitude * force_direction;
1518  }
1519  break;
1520 
1521  default:
1522  break;
1523  }
1524  }
1525 }
1526 
1527 static bool ProcessFreeForce(FreeForceRequest* rq, FreeForce& freeforce)
1528 {
1529  // internal helper for processing add/modify requests, with checks
1530  // ---------------------------------------------------------------
1531 
1532  // Unchecked stuff
1533  freeforce.ffc_id = (FreeForceID_t)rq->ffr_id;
1534  freeforce.ffc_type = (FreeForceType)rq->ffr_type;
1535  freeforce.ffc_force_magnitude = (float)rq->ffr_force_magnitude;
1537  freeforce.ffc_target_coords = rq->ffr_target_coords;
1538 
1539  // Base actor
1541  ROR_ASSERT(freeforce.ffc_base_actor != nullptr && freeforce.ffc_base_actor->ar_state != ActorState::DISPOSED);
1542  if (!freeforce.ffc_base_actor || freeforce.ffc_base_actor->ar_state == ActorState::DISPOSED)
1543  {
1545  fmt::format("Cannot add free force with ID {} to actor {}: Base actor not found or disposed", freeforce.ffc_id, rq->ffr_base_actor));
1546  return false;
1547  }
1548 
1549  // Base node
1550  ROR_ASSERT(rq->ffr_base_node >= 0);
1553  if (rq->ffr_base_node < 0 || rq->ffr_base_node >= NODENUM_MAX || rq->ffr_base_node >= freeforce.ffc_base_actor->ar_num_nodes)
1554  {
1556  fmt::format("Cannot add free force with ID {} to actor {}: Invalid base node number {}", freeforce.ffc_id, rq->ffr_base_actor, rq->ffr_base_node));
1557  return false;
1558  }
1559  freeforce.ffc_base_node = (NodeNum_t)rq->ffr_base_node;
1560 
1561  if (freeforce.ffc_type == FreeForceType::TOWARDS_NODE)
1562  {
1563  // Target actor
1565  ROR_ASSERT(freeforce.ffc_target_actor != nullptr && freeforce.ffc_target_actor->ar_state != ActorState::DISPOSED);
1566  if (!freeforce.ffc_target_actor || freeforce.ffc_target_actor->ar_state == ActorState::DISPOSED)
1567  {
1569  fmt::format("Cannot add free force of type 'TOWARDS_NODE' with ID {} to actor {}: Target actor not found or disposed", freeforce.ffc_id, rq->ffr_target_actor));
1570  return false;
1571  }
1572 
1573  // Target node
1574  ROR_ASSERT(rq->ffr_target_node >= 0);
1577  if (rq->ffr_target_node < 0 || rq->ffr_target_node >= NODENUM_MAX || rq->ffr_target_node >= freeforce.ffc_target_actor->ar_num_nodes)
1578  {
1580  fmt::format("Cannot add free force of type 'TOWARDS_NODE' with ID {} to actor {}: Invalid target node number {}", freeforce.ffc_id, rq->ffr_target_actor, rq->ffr_target_node));
1581  return false;
1582  }
1583  freeforce.ffc_target_node = (NodeNum_t)rq->ffr_target_node;
1584  }
1585 
1586  return true;
1587 }
1588 
1589 ActorManager::FreeForceVec_t::iterator ActorManager::FindFreeForce(FreeForceID_t id)
1590 {
1591  return std::find_if(m_free_forces.begin(), m_free_forces.end(), [id](FreeForce& item) { return id == item.ffc_id; });
1592 }
1593 
1595 {
1596  // Make sure ID is unique
1597  if (this->FindFreeForce(rq->ffr_id) != m_free_forces.end())
1598  {
1600  fmt::format("Cannot add free force with ID {}: ID already in use", rq->ffr_id));
1601  return;
1602  }
1603 
1604  FreeForce freeforce;
1605  if (ProcessFreeForce(rq, freeforce))
1606  {
1607  m_free_forces.push_back(freeforce);
1608  }
1609 }
1610 
1612 {
1613  auto it = this->FindFreeForce(rq->ffr_id);
1614  if (it == m_free_forces.end())
1615  {
1617  fmt::format("Cannot modify free force with ID {}: ID not found", rq->ffr_id));
1618  return;
1619  }
1620 
1621  FreeForce& freeforce = *it;
1622  if (ProcessFreeForce(rq, freeforce))
1623  {
1624  *it = freeforce;
1625  }
1626 }
1627 
1629 {
1630  auto it = this->FindFreeForce(id);
1631  if (it == m_free_forces.end())
1632  {
1634  fmt::format("Cannot remove free force with ID {}: ID not found", id));
1635  return;
1636  }
1637 
1638  m_free_forces.erase(it);
1639 }
ROR_ASSERT
#define ROR_ASSERT(_EXPR)
Definition: Application.h:40
GameContext.h
Game state manager and message-queue provider.
RoR::ScriptEngine::unloadScript
void unloadScript(ScriptUnitID_t unique_id)
Unloads a script.
Definition: ScriptEngine.cpp:1033
RoR::Actor::ar_avg_wheel_speed
float ar_avg_wheel_speed
Physics state; avg wheel speed in m/s.
Definition: Actor.h:399
MAX_COMMANDS
static const int MAX_COMMANDS
maximum number of commands per actor
Definition: SimConstants.h:28
RoR::GfxActor::SetDebugView
void SetDebugView(DebugViewType dv)
Definition: GfxActor.cpp:1576
RoR::Actor::resetPosition
void resetPosition(Ogre::Vector3 translation, bool setInitPosition)
Moves the actor to given world coords (pivot point is node 0).
Definition: Actor.cpp:1262
RoR::Actor::cc_mode
bool cc_mode
Cruise Control.
Definition: Actor.h:361
RoR::App::GetNetwork
Network * GetNetwork()
Definition: Application.cpp:287
RoRnet::ActorStreamRegister
< Must preserve mem. layout of RoRnet::StreamRegister
Definition: RoRnet.h:158
RoR::ActorManager::GetSimulationSpeed
float GetSimulationSpeed() const
Definition: ActorManager.h:92
RoR::ActorManager::CheckNetworkStreamsOk
int CheckNetworkStreamsOk(int sourceid)
Definition: ActorManager.cpp:521
RoR::EV_COMMON_REPLAY_FORWARD
@ EV_COMMON_REPLAY_FORWARD
Definition: InputEngine.h:255
RoR::Actor
Softbody object; can be anything from soda can to a space shuttle Constructed from a truck definition...
Definition: Actor.h:50
RoR::Actor::ar_vehicle_ai
VehicleAIPtr ar_vehicle_ai
Definition: Actor.h:394
RoR::ActorSpawnRequest::asr_net_color
int asr_net_color
Definition: SimData.h:842
RoR::ActorSpawnRequest::asr_free_position
bool asr_free_position
Disables the automatic spawn position adjustment.
Definition: SimData.h:846
RoRnet::MSG2_STREAM_UNREGISTER
@ MSG2_STREAM_UNREGISTER
remove stream
Definition: RoRnet.h:65
BITMASK_SET
void BITMASK_SET(BitMask_t &mask, BitMask_t flag, bool val)
Definition: BitFlags.h:19
RoR::Actor::m_section_config
Ogre::String m_section_config
Definition: Actor.h:549
RoR::ActorSpawnRequest::Origin::NETWORK
@ NETWORK
Remote controlled.
RoR::MSG_SIM_MODIFY_ACTOR_REQUESTED
@ MSG_SIM_MODIFY_ACTOR_REQUESTED
Payload = RoR::ActorModifyRequest* (owner)
Definition: Application.h:122
RoR::FreeForce::ffc_target_node
NodeNum_t ffc_target_node
Definition: SimData.h:781
RoR::EV_COMMON_TOGGLE_PHYSICS
@ EV_COMMON_TOGGLE_PHYSICS
toggle physics on/off
Definition: InputEngine.h:271
RoR::Actor::ar_physics_paused
bool ar_physics_paused
Actor physics individually paused by user.
Definition: Actor.h:456
RoRnet::ActorStreamRegister::time
int32_t time
initial time stamp
Definition: RoRnet.h:168
RoR::FreeForceRequest::ffr_target_node
int64_t ffr_target_node
Definition: SimData.h:799
RoR::GfxActor::UpdateSimDataBuffer
void UpdateSimDataBuffer()
Copies sim. data from Actor to GfxActor for later update.
Definition: GfxActor.cpp:1775
RoR::TRUCK
@ TRUCK
its a truck (or other land vehicle)
Definition: SimData.h:93
RoR::Actor::ar_filename
std::string ar_filename
Attribute; filled at spawn.
Definition: Actor.h:422
RoR::MpState::CONNECTED
@ CONNECTED
RoR::ActorManager::GetNetTimeOffset
int GetNetTimeOffset(int sourceid)
Definition: ActorManager.cpp:503
RoR::ActorManager::ACTORPTR_NULL
static const ActorPtr ACTORPTR_NULL
Definition: ActorManager.h:126
RoR::ActorSpawner::ConfigureSections
void ConfigureSections(Ogre::String const &sectionconfig, RigDef::DocumentPtr def)
Definition: ActorSpawner.cpp:90
RoR::TyrePressure::ModifyTyrePressure
bool ModifyTyrePressure(float v)
Definition: TyrePressure.cpp:64
RoR::ActorSpawnRequest::Origin::CONFIG_FILE
@ CONFIG_FILE
'Preselected vehicle' in RoR.cfg or command line
RoR::ActorSpawnRequest::asr_origin
Origin asr_origin
Definition: SimData.h:839
RoR::ActorSpawner::ActorMemoryRequirements::num_fixes
size_t num_fixes
Definition: ActorSpawner.h:84
RoR::Actor::ar_vector_index
unsigned int ar_vector_index
Sim attr; actor element index in std::vector<m_actors>
Definition: Actor.h:374
RoR::node_t::AbsPosition
Ogre::Vector3 AbsPosition
absolute position in the world (shaky)
Definition: SimData.h:294
RoR::ActorManager::m_actors
ActorPtrVec m_actors
Use MSG_SIM_{SPAWN/DELETE}_ACTOR_REQUESTED
Definition: ActorManager.h:144
VehicleAI.h
Simple waypoint AI.
RoR::App::diag_actor_dump
CVar * diag_actor_dump
Definition: Application.cpp:158
RoR::Actor::ar_parking_brake
bool ar_parking_brake
Definition: Actor.h:411
RoR::Collisions
Definition: Collisions.h:80
RoRnet::UserInfo
Definition: RoRnet.h:178
RoR::ActorLinkingRequest
Estabilishing a physics linkage between 2 actors modifies a global linkage table and triggers immedia...
Definition: SimData.h:904
DashBoardManager.h
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::Actor::ar_instance_id
ActorInstanceID_t ar_instance_id
Static attr; session-unique ID.
Definition: Actor.h:373
RoR::Actor::m_net_first_wheel_node
int m_net_first_wheel_node
Network attr; Determines data buffer layout; calculated on spawn.
Definition: Actor.h:616
RoR::Actor::ar_num_nodes
int ar_num_nodes
Definition: Actor.h:290
HandleErrorLoadingTruckfile
void HandleErrorLoadingTruckfile(std::string filename, std::string exception_msg)
Definition: ActorManager.cpp:1238
RoR::Actor::ar_bounding_box
Ogre::AxisAlignedBox ar_bounding_box
standard bounding box (surrounds all nodes of an actor)
Definition: Actor.h:312
RigDef::Parser::GetFile
RigDef::DocumentPtr GetFile()
Definition: RigDef_Parser.h:77
RigDef::Parser::Finalize
void Finalize()
Definition: RigDef_Parser.cpp:2850
ContentManager.h
GUI_TopMenubar.h
RoR::App::gfx_skidmarks_mode
CVar * gfx_skidmarks_mode
Definition: Application.cpp:235
ThreadPool.h
RoR::NODENUM_INVALID
static const NodeNum_t NODENUM_INVALID
Definition: ForwardDeclarations.h:55
RoR::ActorState::LOCAL_REPLAY
@ LOCAL_REPLAY
RoR::GfxActor::UpdateRods
void UpdateRods()
Definition: GfxActor.cpp:1646
RoR::Collisions::defaultgm
ground_model_t * defaultgm
Definition: Collisions.h:174
format
Truck file format(technical spec)
RoR::ActorManager::AddFreeForce
void AddFreeForce(FreeForceRequest *rq)
Definition: ActorManager.cpp:1594
HandleErrorLoadingFile
void HandleErrorLoadingFile(std::string type, std::string filename, std::string exception_msg)
Definition: ActorManager.cpp:1230
RoR::collision_box_t::lo
Ogre::Vector3 lo
absolute collision box
Definition: SimData.h:704
RoR::ActorManager::inter_actor_links
std::map< beam_t *, std::pair< ActorPtr, ActorPtr > > inter_actor_links
Definition: ActorManager.h:123
RoR::Actor::sendStreamSetup
void sendStreamSetup()
Definition: Actor.cpp:1914
RoR::Engine::getAutoMode
SimGearboxMode getAutoMode()
Definition: Engine.cpp:842
RoR::DebugViewType
DebugViewType
Definition: GfxData.h:101
RoR::ActorState::DISPOSED
@ DISPOSED
removed from simulation, still in memory to satisfy pointers.
RoRnet::LIGHTMASK_REVERSE
@ LIGHTMASK_REVERSE
reverse light on
Definition: RoRnet.h:119
RoR::ActorManager::RemoveStreamSource
void RemoveStreamSource(int sourceid)
Definition: ActorManager.cpp:336
RoR::ActorLinkingRequest::alr_type
ActorLinkingRequestType alr_type
Definition: SimData.h:907
RoR::Actor::m_min_camera_radius
Ogre::Real m_min_camera_radius
Definition: Actor.h:562
RoR::CVar::getBool
bool getBool() const
Definition: CVar.h:98
RoR::TRIGGER_EVENT_ASYNC
void TRIGGER_EVENT_ASYNC(scriptEvents type, int arg1, int arg2ex=0, int arg3ex=0, int arg4ex=0, std::string arg5ex="", std::string arg6ex="", std::string arg7ex="", std::string arg8ex="")
Asynchronously (via MSG_SIM_SCRIPT_EVENT_TRIGGERED) invoke script function eventCallbackEx(),...
Definition: ScriptEngine.h:51
RoR::Actor::ar_brake
Ogre::Real ar_brake
Physics state; braking intensity.
Definition: Actor.h:396
RoR::Actor::sl_enabled
bool sl_enabled
Speed limiter;.
Definition: Actor.h:367
RoR::ActorManager::FindActorInsideBox
ActorPtr FindActorInsideBox(Collisions *collisions, const Ogre::String &inst, const Ogre::String &box)
Definition: ActorManager.cpp:809
RoR::Replay::replayStepActor
void replayStepActor()
Definition: Replay.cpp:215
RigDef::Parser
Checks the rig-def file syntax and pulls data to File object.
Definition: RigDef_Parser.h:56
RoR::beam_t::strength
float strength
Definition: SimData.h:343
RoR::ActorManager::CheckActorCollAabbIntersect
bool CheckActorCollAabbIntersect(int a, int b)
Returns whether or not the bounding boxes of truck a and truck b intersect. Based on the truck collis...
Definition: ActorManager.cpp:572
RoR::Round
Ogre::Real Round(Ogre::Real value, unsigned short ndigits=0)
Definition: Utils.cpp:98
RoR::FreeForce::ffc_force_magnitude
float ffc_force_magnitude
Definition: SimData.h:774
RoR::LogFormat
void LogFormat(const char *format,...)
Improved logging utility. Uses fixed 2Kb buffer.
Definition: Application.cpp:427
DynamicCollisions.h
RoR::SplitBundleQualifiedFilename
void SplitBundleQualifiedFilename(const std::string &bundleQualifiedFilename, std::string &out_bundleName, std::string &out_filename)
Definition: Utils.cpp:228
RoRnet::StreamRegister::origin_sourceid
int32_t origin_sourceid
origin sourceid
Definition: RoRnet.h:152
RoR::App::sim_replay_length
CVar * sim_replay_length
Definition: Application.cpp:102
RoR::collision_box_t::hi
Ogre::Vector3 hi
absolute collision box
Definition: SimData.h:705
RoR::Actor::ar_toggle_ropes
bool ar_toggle_ropes
Sim state.
Definition: Actor.h:492
Console.h
RoR::Console::putMessage
void putMessage(MessageArea area, MessageType type, std::string const &msg, std::string icon="")
Definition: Console.cpp:103
RoR::Actor::ar_hooks
std::vector< hook_t > ar_hooks
Definition: Actor.h:308
RoR::Actor::ar_trailer_parking_brake
bool ar_trailer_parking_brake
Definition: Actor.h:412
RoR::CacheEntry::resource_group
Ogre::String resource_group
Resource group of the loaded bundle. Empty if not loaded yet.
Definition: CacheSystem.h:89
RoR::ActorManager::GetActors
ActorPtrVec & GetActors()
Definition: ActorManager.h:118
MovableText.h
This creates a billboarding object that displays a text.
RoR::Actor::sl_speed_limit
float sl_speed_limit
Speed limiter;.
Definition: Actor.h:368
RoR::ActorSpawner::ConfigureAddonParts
void ConfigureAddonParts(TuneupDefPtr &tuneup_def)
Definition: ActorSpawner.cpp:109
RoR::ActorManager::GetActorByNetworkLinks
const ActorPtr & GetActorByNetworkLinks(int source_id, int stream_id)
Definition: ActorManager.cpp:559
RoR::SE_GENERIC_NEW_TRUCK
@ SE_GENERIC_NEW_TRUCK
triggered when the user spawns a new actor, the argument refers to the actor ID
Definition: ScriptEvents.h:47
RoR::ActorManager::FetchPreviousVehicleOnList
const ActorPtr & FetchPreviousVehicleOnList(ActorPtr player, ActorPtr prev_player)
Definition: ActorManager.cpp:977
RoR::GfxActor::UpdateCabMesh
void UpdateCabMesh()
Definition: GfxActor.cpp:1951
TuneupFileFormat.h
The vehicle tuning system; applies addonparts and user overrides to vehicles.
RoR::GfxActor::FinishFlexbodyTasks
void FinishFlexbodyTasks()
Definition: GfxActor.cpp:3230
RoR::FreeForce::ffc_target_actor
ActorPtr ffc_target_actor
Definition: SimData.h:780
RoR::FreeForceType
FreeForceType
Definition: SimData.h:760
RoR::Actor::GetGfxActor
GfxActor * GetGfxActor()
Definition: Actor.h:275
RoR::ActorManager::GetNearestActor
std::pair< ActorPtr, float > GetNearestActor(Ogre::Vector3 position)
Definition: ActorManager.cpp:842
RigDef::Validator::Setup
void Setup(RigDef::DocumentPtr file)
Prepares the validation.
Definition: RigDef_Validator.cpp:85
RoR::ActorManager::SyncWithSimThread
void SyncWithSimThread()
Definition: ActorManager.cpp:1224
RoR::ActorLinkingRequestType::ROPE_TOGGLE
@ ROPE_TOGGLE
RoR::ActorState::LOCAL_SIMULATED
@ LOCAL_SIMULATED
simulated (local) actor
Engine.h
Utils.h
RoR::ActorManager::AreActorsDirectlyLinked
bool AreActorsDirectlyLinked(const ActorPtr &a1, const ActorPtr &a2)
Definition: ActorManager.cpp:726
RoR::ActorSpawnRequest::asr_filename
std::string asr_filename
Can be in "Bundle-qualified" format, i.e. "mybundle.zip:myactor.truck".
Definition: SimData.h:831
RoR::node_t::RelPosition
Ogre::Vector3 RelPosition
relative to the local physics origin (one origin per actor) (shaky)
Definition: SimData.h:293
RoR::Network::GetUserPeerOpts
bool GetUserPeerOpts(int uid, BitMask_t &result)
Definition: Network.cpp:735
Language.h
RoR::FreeForceRequest::ffr_base_actor
int64_t ffr_base_actor
Definition: SimData.h:793
RoR::ActorManager::m_stream_time_offsets
std::map< int, int > m_stream_time_offsets
Networking: A network time offset for each stream source.
Definition: ActorManager.h:140
RefCountingObjectPtr< Actor >
ActorSpawner.h
Vehicle spawning logic.
RoR::Console::CONSOLE_SYSTEM_ERROR
@ CONSOLE_SYSTEM_ERROR
Definition: Console.h:52
RigDef::Parser::ProcessOgreStream
void ProcessOgreStream(Ogre::DataStream *stream, Ogre::String resource_group)
Definition: RigDef_Parser.cpp:3405
RoR::FreeForce::ffc_base_node
NodeNum_t ffc_base_node
Definition: SimData.h:776
GUIManager.h
RoR::Actor::ar_forward_commands
bool ar_forward_commands
Sim state.
Definition: Actor.h:490
RoR::NODENUM_MAX
static const NodeNum_t NODENUM_MAX
Definition: ForwardDeclarations.h:56
ActorManager.h
Actor.h
RoR::collision_box_t::center
Ogre::Vector3 center
center of rotation
Definition: SimData.h:706
RoR::App::GetScriptEngine
ScriptEngine * GetScriptEngine()
Definition: Application.cpp:282
RoR::App::mp_cyclethru_net_actors
CVar * mp_cyclethru_net_actors
Include remote actors when cycling through with CTRL + [ and CTRL + ].
Definition: Application.cpp:127
RoR::ActorSpawner
Processes a RigDef::Document (parsed from 'truck' file format) into a simulated gameplay object (Acto...
Definition: ActorSpawner.h:70
RoR::Console::CONSOLE_SYSTEM_NOTICE
@ CONSOLE_SYSTEM_NOTICE
Definition: Console.h:51
RoR::Actor::m_net_wheel_buf_size
size_t m_net_wheel_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition: Actor.h:612
RoR::ActorSpawnRequest
Definition: SimData.h:813
RoR::Actor::ar_wheel_speed
float ar_wheel_speed
Physics state; wheel speed in m/s.
Definition: Actor.h:397
RoR::ActorManager::SendAllActorsSleeping
void SendAllActorsSleeping()
Definition: ActorManager.cpp:797
RoR::SimGearboxMode::AUTO
@ AUTO
Automatic shift.
RoR::beam_t::initial_beam_strength
float initial_beam_strength
for reset
Definition: SimData.h:360
RoR::FreeForce::ffc_id
FreeForceID_t ffc_id
Definition: SimData.h:772
RoR::ActorManager::AddStreamMismatch
void AddStreamMismatch(int sourceid, int streamid)
Definition: ActorManager.h:86
RoR::GfxActor::FinishWheelUpdates
void FinishWheelUpdates()
Definition: GfxActor.cpp:1977
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
Replay.h
RoR::ActorModifyRequest::amr_actor
ActorInstanceID_t amr_actor
Definition: SimData.h:871
RoR::Actor::getReplay
Replay * getReplay()
Definition: Actor.cpp:4516
RoR::EV_COMMON_ACCELERATE_SIMULATION
@ EV_COMMON_ACCELERATE_SIMULATION
accelerate the simulation speed
Definition: InputEngine.h:223
RoR::GfxActor::UpdateProps
void UpdateProps(float dt, bool is_player_actor)
Definition: GfxActor.cpp:2302
RoR::FreeForce::ffc_type
FreeForceType ffc_type
Definition: SimData.h:773
RoR::Actor::m_disable_default_sounds
bool m_disable_default_sounds
Spawner context; TODO: remove.
Definition: Actor.h:642
RoR::ActorSpawnRequest::asr_config
Ogre::String asr_config
Definition: SimData.h:832
TOSTRING
#define TOSTRING(x)
Definition: Application.h:56
RoR::Actor::getAvgPropedWheelRadius
float getAvgPropedWheelRadius()
Definition: Actor.h:263
RoR::Actor::isPreloadedWithTerrain
bool isPreloadedWithTerrain() const
Definition: Actor.h:244
RoR::VehicleAI::isActive
bool isActive()
Returns the status of the AI.
Definition: VehicleAI.cpp:58
RoR::ActorManager::m_simulation_speed
float m_simulation_speed
slow motion < 1.0 < fast motion
Definition: ActorManager.h:149
RoR::ActorManager::m_stream_mismatches
std::map< int, std::set< int > > m_stream_mismatches
Networking: A set of streams without a corresponding actor in the actor-array for each stream source.
Definition: ActorManager.h:139
RoR::Engine::offStart
void offStart()
Quick start of vehicle engine.
Definition: Engine.cpp:1013
RoR::FreeForceType::TOWARDS_COORDS
@ TOWARDS_COORDS
Constant force directed towards ffc_target_coords
RoR::ActorInstanceID_t
int ActorInstanceID_t
Unique sequentially generated ID of an actor in session. Use ActorManager::GetActorById()
Definition: ForwardDeclarations.h:38
RoR::ActorManager::CalcFreeForces
void CalcFreeForces()
Apply FreeForces - intentionally as a separate pass over all actors.
Definition: ActorManager.cpp:1484
RoR::ActorManager::UpdateSleepingState
void UpdateSleepingState(ActorPtr player_actor, float dt)
Definition: ActorManager.cpp:740
RoR::Actor::ar_beams
beam_t * ar_beams
Definition: Actor.h:294
RoR::ActorManager::PredictActorCollAabbIntersect
bool PredictActorCollAabbIntersect(int a, int b)
Returns whether or not the bounding boxes of truck a and truck b might intersect during the next fram...
Definition: ActorManager.cpp:601
RoR::ActorManager::m_simulation_paused
bool m_simulation_paused
Definition: ActorManager.h:152
RoRnet::MSG2_STREAM_DATA
@ MSG2_STREAM_DATA
stream data
Definition: RoRnet.h:66
RoR::NodeNum_t
uint16_t NodeNum_t
Node position within Actor::ar_nodes; use RoR::NODENUM_INVALID as empty value.
Definition: ForwardDeclarations.h:54
RoR::ActorManager::m_dt_remainder
float m_dt_remainder
Keeps track of the rounding error in the time step calculation.
Definition: ActorManager.h:148
RoR::Str< 200 >
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
RoR::Collisions::getGroundModelByString
ground_model_t * getGroundModelByString(const Ogre::String name)
Definition: Collisions.cpp:365
RoR::ActorManager::RemoveFreeForce
void RemoveFreeForce(FreeForceID_t id)
Definition: ActorManager.cpp:1628
RoR::Actor::ar_engine
EnginePtr ar_engine
Definition: Actor.h:376
RigDef::Validator
Performs a formal validation of the file (missing required parts, conflicts of modules,...
Definition: RigDef_Validator.h:47
RoR::beam_t::d
float d
damping factor
Definition: SimData.h:338
RoR::ActorManager::FindFreeForce
FreeForceVec_t::iterator FindFreeForce(FreeForceID_t id)
Definition: ActorManager.cpp:1589
RigDef_Validator.h
.truck format validator
RoR::ActorModifyRequest
Definition: SimData.h:853
RoR::FreeForce::ffc_force_const_direction
Ogre::Vector3 ffc_force_const_direction
Expected to be normalized; only effective with FreeForceType::CONSTANT
Definition: SimData.h:778
RoR::GfxScene::RegisterGfxActor
void RegisterGfxActor(RoR::GfxActor *gfx_actor)
Definition: GfxScene.cpp:283
CacheSystem.h
A database of user-installed content alias 'mods' (vehicles, terrains...)
RoR::collision_box_t::relo
Ogre::Vector3 relo
relative collision box
Definition: SimData.h:712
RoR::ActorManager::m_sim_task
std::shared_ptr< Task > m_sim_task
Definition: ActorManager.h:159
RoR::ActorSpawner::ConfigureAssetPacks
void ConfigureAssetPacks(ActorPtr actor, RigDef::DocumentPtr def)
Definition: ActorSpawner.cpp:143
RoR::ActorManager::HandleActorStreamData
void HandleActorStreamData(std::vector< RoR::NetRecvPacket > packet)
Definition: ActorManager.cpp:353
RoR::Engine::setAcc
void setAcc(float val)
Definition: Engine.cpp:852
RoR::ACTORINSTANCEID_INVALID
static const ActorInstanceID_t ACTORINSTANCEID_INVALID
Definition: ForwardDeclarations.h:39
RoRnet::MSG2_STREAM_REGISTER
@ MSG2_STREAM_REGISTER
create new stream
Definition: RoRnet.h:63
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::Actor::getTyrePressure
TyrePressure & getTyrePressure()
Definition: Actor.h:225
RoR::GameContext::PushMessage
void PushMessage(Message m)
Doesn't guarantee order! Use ChainMessage() if order matters.
Definition: GameContext.cpp:66
strnlen
#define strnlen(str, len)
Definition: InputEngine.cpp:400
RoR::ActorManager::GetLocalActors
std::vector< ActorPtr > GetLocalActors()
Definition: ActorManager.cpp:1322
RoR::ActorManager::m_sim_thread_pool
std::unique_ptr< ThreadPool > m_sim_thread_pool
Definition: ActorManager.h:158
RoR::Replay
Definition: Replay.h:39
RoR::ThreadPool
Facilitates execution of (small) tasks on separate threads.
Definition: ThreadPool.h:105
RoR::Actor::updateVisual
void updateVisual(float dt=0)
Definition: Actor.cpp:3188
ChatSystem.h
RoR::ActorSpawner::ProcessNewActor
void ProcessNewActor(ActorPtr actor, ActorSpawnRequest rq, RigDef::DocumentPtr def)
Definition: ActorSpawnerFlow.cpp:59
RoR::Actor::ar_origin
Ogre::Vector3 ar_origin
Physics state; base position for softbody nodes.
Definition: Actor.h:382
RoR::Str::ToCStr
const char * ToCStr() const
Definition: Str.h:46
RoR::ActorState::LOCAL_SLEEPING
@ LOCAL_SLEEPING
sleeping (local) actor
RoR::FreeForceID_t
int FreeForceID_t
Unique sequentially generated ID of FreeForce; use ActorManager::GetFreeForceNextId().
Definition: ForwardDeclarations.h:67
RoR::Actor::ar_command_key
CmdKeyArray ar_command_key
BEWARE: commandkeys are indexed 1-MAX_COMMANDS!
Definition: Actor.h:311
RoR::FreeForceType::CONSTANT
@ CONSTANT
Constant force given by direction and magnitude.
RoR::Terrain::GetCollisions
Collisions * GetCollisions()
Definition: Terrain.h:82
RoR::CacheEntry::actor_def
RigDef::DocumentPtr actor_def
Cached actor definition (aka truckfile) after first spawn.
Definition: CacheSystem.h:91
RoR::Actor::getPosition
Ogre::Vector3 getPosition()
Definition: Actor.cpp:371
RoR::FreeForceRequest::ffr_target_coords
Ogre::Vector3 ffr_target_coords
Definition: SimData.h:797
GfxScene.h
RoR::node_t::nd_tyre_node
bool nd_tyre_node
Attr; This node is part of a tyre (note some wheel types don't use rim nodes at all)
Definition: SimData.h:311
RoR::Actor::NotifyActorCameraChanged
void NotifyActorCameraChanged()
Logic: sound, display; Notify this vehicle that camera changed;.
Definition: Actor.cpp:3795
RoR::Actor::ForceFeedbackStep
void ForceFeedbackStep(int steps)
Definition: Actor.cpp:1755
RoR::Actor::WriteDiagnosticDump
void WriteDiagnosticDump(std::string const &filename)
Definition: Actor.cpp:4579
RoR::EV_COMMON_REPLAY_FAST_FORWARD
@ EV_COMMON_REPLAY_FAST_FORWARD
Definition: InputEngine.h:254
RoR::ActorLinkingRequest::alr_rope_group
int alr_rope_group
Definition: SimData.h:914
RoR::Actor::ar_import_commands
bool ar_import_commands
Sim state.
Definition: Actor.h:491
FindPivotActorId
int FindPivotActorId(ActorPtr player, ActorPtr prev_player)
Definition: ActorManager.cpp:927
RoR::ActorManager::UpdateNetTimeOffset
void UpdateNetTimeOffset(int sourceid, int offset)
Definition: ActorManager.cpp:513
RoR::ActorManager::m_physics_steps
int m_physics_steps
Definition: ActorManager.h:147
Application.h
Central state/object manager and communications hub.
RoR::Actor::m_net_propanimkey_buf_size
size_t m_net_propanimkey_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition: Actor.h:613
RoR::App::GetConsole
Console * GetConsole()
Definition: Application.cpp:273
RoR::FreeForce::ffc_base_actor
ActorPtr ffc_base_actor
Definition: SimData.h:775
RoR::Actor::m_net_color_num
int m_net_color_num
Definition: Actor.h:619
RigDef::Parser::Prepare
void Prepare()
Definition: RigDef_Parser.cpp:2733
RoRnet::MSG2_STREAM_REGISTER_RESULT
@ MSG2_STREAM_REGISTER_RESULT
result of a stream creation
Definition: RoRnet.h:64
SoundScriptManager.h
RoR::Actor::ar_initial_beam_defaults
std::vector< std::pair< float, float > > ar_initial_beam_defaults
Definition: Actor.h:318
RoR::App::GetGameContext
GameContext * GetGameContext()
Definition: Application.cpp:283
RoR::Actor::UpdateCruiseControl
void UpdateCruiseControl(float dt)
Defined in 'gameplay/CruiseControl.cpp'.
Definition: CruiseControl.cpp:48
RoR::ActorManager::FetchRescueVehicle
const ActorPtr & FetchRescueVehicle()
Definition: ActorManager.cpp:1004
RoR::Actor::m_lightmask
BitMask_t m_lightmask
RoRnet::Lightmask.
Definition: Actor.h:625
RoR::Actor::m_dry_mass
float m_dry_mass
Physics attr;.
Definition: Actor.h:596
RoR::FreeForceRequest::ffr_force_magnitude
double ffr_force_magnitude
Definition: SimData.h:792
RigDef::Validator::SetCheckBeams
void SetCheckBeams(bool check_beams)
Definition: RigDef_Validator.h:77
RoR::FreeForce
Global force affecting particular (base) node of particular (base) actor; added ad-hoc by scripts.
Definition: SimData.h:769
RoR::ActorManager::m_total_sim_time
float m_total_sim_time
Definition: ActorManager.h:153
RoR::Actor::m_prop_anim_key_states
std::vector< PropAnimKeyState > m_prop_anim_key_states
Definition: Actor.h:607
RoR::Actor::ar_initial_total_mass
float ar_initial_total_mass
Definition: Actor.h:315
RoR::Actor::ar_sleep_counter
float ar_sleep_counter
Sim state; idle time counter.
Definition: Actor.h:409
RoR::Actor::m_spawn_rotation
float m_spawn_rotation
Definition: Actor.h:571
RoR::Actor::getDirection
Ogre::Vector3 getDirection()
average actor velocity, calculated using the actor positions of the last two frames
Definition: Actor.cpp:366
RoR::ActorSpawnRequest::net_stream_id
int net_stream_id
Definition: SimData.h:845
RoR::ActorSpawnRequest::Origin::TERRN_DEF
@ TERRN_DEF
Preloaded with terrain.
RoR::ActorSpawnRequest::asr_skin_entry
CacheEntryPtr asr_skin_entry
Definition: SimData.h:836
RoRnet::LIGHTMASK_BRAKES
@ LIGHTMASK_BRAKES
brake lights on
Definition: RoRnet.h:118
RoR::ActorManager::m_simulation_time
float m_simulation_time
Amount of time the physics simulation is going to be advanced.
Definition: ActorManager.h:151
RoR::Actor::ar_num_beams
int ar_num_beams
Definition: Actor.h:295
RoR::ActorManager::SetSimulationSpeed
void SetSimulationSpeed(float speed)
Definition: ActorManager.h:91
RoR::Actor::m_preloaded_with_terrain
bool m_preloaded_with_terrain
Spawn context (TODO: remove!)
Definition: Actor.h:638
RoR::Actor::m_replay_handler
Replay * m_replay_handler
Definition: Actor.h:566
RoR::Actor::getTotalMass
float getTotalMass(bool withLocked=true)
Definition: Actor.cpp:754
RoR::Actor::m_net_total_buffer_size
size_t m_net_total_buffer_size
For incoming/outgoing traffic; calculated on spawn.
Definition: Actor.h:614
RoR::ActorManager::m_last_simulation_speed
float m_last_simulation_speed
previously used time ratio between real time (evt.timeSinceLastFrame) and physics time ('dt' used in ...
Definition: ActorManager.h:150
RoR::Actor::RecalculateNodeMasses
void RecalculateNodeMasses(Ogre::Real total)
Previously 'calc_masses2()'.
Definition: Actor.cpp:662
RoR::Actor::ar_num_cinecams
int ar_num_cinecams
Sim attr;.
Definition: Actor.h:378
RoRnet::StreamRegister::status
int32_t status
initial stream status
Definition: RoRnet.h:151
PointColDetector.h
RoR::ActorManager::RecursiveActivation
void RecursiveActivation(int j, std::vector< bool > &visited)
Definition: ActorManager.cpp:630
RoR::SanitizeUtf8CString
std::string SanitizeUtf8CString(const char *start, const char *end=nullptr)
Definition: Utils.cpp:125
RoR::Actor::m_total_mass
float m_total_mass
Physics state; total mass in Kg.
Definition: Actor.h:567
RoRnet::StreamRegister::type
int32_t type
0 = Actor, 1 = Character, 3 = ChatSystem
Definition: RoRnet.h:150
RoR::ScriptEngine::loadScript
ScriptUnitID_t loadScript(Ogre::String scriptname, ScriptCategory category=ScriptCategory::TERRAIN, ActorPtr associatedActor=nullptr, std::string buffer="")
Loads a script.
Definition: ScriptEngine.cpp:828
RoR::ActorManager::DeleteActorInternal
void DeleteActorInternal(ActorPtr actor)
Do not call directly; use GameContext::DeleteActor()
Definition: ActorManager.cpp:871
RigDef::Script
Definition: RigDef_File.h:1177
RoR::Actor::m_net_node_buf_size
size_t m_net_node_buf_size
For incoming/outgoing traffic; calculated on spawn.
Definition: Actor.h:611
RoR::App::sim_realistic_commands
CVar * sim_realistic_commands
Definition: Application.cpp:104
RoR::Actor::ar_initial_node_positions
std::vector< Ogre::Vector3 > ar_initial_node_positions
Absolute world positions, for resetting to pristine state.
Definition: Actor.h:317
RoR::App::GetCacheSystem
CacheSystem * GetCacheSystem()
Definition: Application.cpp:275
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
ProcessFreeForce
static bool ProcessFreeForce(FreeForceRequest *rq, FreeForce &freeforce)
Definition: ActorManager.cpp:1527
RoRnet::UserInfo::colournum
int32_t colournum
colour set by server
Definition: RoRnet.h:183
RigDef::Script::filename
std::string filename
Definition: RigDef_File.h:1179
RoRnet::StreamRegister::name
char name[128]
file name
Definition: RoRnet.h:154
RoR::Actor::ar_nodes
node_t * ar_nodes
Definition: Actor.h:285
RoR::FreeForceRequest
Common for ADD and MODIFY requests; tailored for use with AngelScript thru GameScript::pushMessage().
Definition: SimData.h:785
RoRnet::UserInfo::username
char username[RORNET_MAX_USERNAME_LEN]
the nickname of the user (UTF-8)
Definition: RoRnet.h:185
RoR::ActorLinkingRequest::alr_tie_group
int alr_tie_group
Definition: SimData.h:912
RoR::Actor::ar_toggle_ties
bool ar_toggle_ties
Sim state.
Definition: Actor.h:493
RoR::Actor::getRotation
float getRotation()
Definition: Actor.cpp:356
RoR::node_t::nd_rim_node
bool nd_rim_node
Attr; This node is part of a rim (only wheel types with separate rim nodes)
Definition: SimData.h:310
RoR::beam_t::k
float k
tensile spring
Definition: SimData.h:337
RoR::CacheSystem::LoadResource
void LoadResource(CacheEntryPtr &t)
Loads the associated resource bundle if not already done.
Definition: CacheSystem.cpp:1440
RoR::MSG_SIM_ACTOR_LINKING_REQUESTED
@ MSG_SIM_ACTOR_LINKING_REQUESTED
Payload = RoR::ActorLinkingRequest* (owner)
Definition: Application.h:132
RoR::Message
Unified game event system - all requests and state changes are reported using a message.
Definition: GameContext.h:51
RoR::Actor::ar_initial_node_masses
std::vector< float > ar_initial_node_masses
Definition: Actor.h:316
RoR::ActorManager::m_net_timer
Ogre::Timer m_net_timer
Definition: ActorManager.h:141
_L
#define _L
Definition: ErrorUtils.cpp:34
PHYSICS_DT
#define PHYSICS_DT
Definition: SimConstants.h:20
RoR::Console::putNetMessage
void putNetMessage(int user_id, MessageType type, const char *text)
Definition: Console.cpp:108
RoR::ActorManager::~ActorManager
~ActorManager()
Definition: ActorManager.cpp:73
SOUND_PLAY_ONCE
#define SOUND_PLAY_ONCE(_ACTOR_, _TRIG_)
Definition: SoundScriptManager.h:34
RoR::Actor::dispose
void dispose()
Effectively destroys the object but keeps it in memory to satisfy shared pointers.
Definition: Actor.cpp:89
RoR::ActorSpawnRequest::asr_net_username
Ogre::UTFString asr_net_username
Definition: SimData.h:841
RoR::ActorSpawnRequest::asr_debugview
int asr_debugview
Definition: SimData.h:840
RoR::Actor::m_net_username
Ogre::UTFString m_net_username
Definition: Actor.h:618
RoR::ActorManager::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: ActorManager.cpp:1333
RoR::Actor::m_working_tuneup_def
TuneupDefPtr m_working_tuneup_def
Each actor gets unique instance, even if loaded from .tuneup file in modcache.
Definition: Actor.h:600
RoR::Engine::getAcc
float getAcc()
Definition: Engine.cpp:880
RoR::GfxActor::UpdateWingMeshes
void UpdateWingMeshes()
Definition: GfxActor.cpp:3403
RoR::beam_t::minmaxposnegstress
float minmaxposnegstress
Definition: SimData.h:340
RoR::FreeForceType::TOWARDS_NODE
@ TOWARDS_NODE
Constant force directed towards ffc_target_node
RoR::MSG_SIM_SPAWN_ACTOR_REQUESTED
@ MSG_SIM_SPAWN_ACTOR_REQUESTED
Payload = RoR::ActorSpawnRequest* (owner)
Definition: Application.h:121
RoR::Actor::ar_num_wheels
int ar_num_wheels
Definition: Actor.h:330
RoRnet::StreamRegister::origin_streamid
int32_t origin_streamid
origin streamid
Definition: RoRnet.h:153
RoR::App::GetInputEngine
InputEngine * GetInputEngine()
Definition: Application.cpp:274
RoR::ActorManager::ModifyFreeForce
void ModifyFreeForce(FreeForceRequest *rq)
Definition: ActorManager.cpp:1611
RoR::EraseIf
void EraseIf(std::vector< T, A > &c, Predicate pred)
Definition: Utils.h:74
RoR::Actor::m_avg_node_position
Ogre::Vector3 m_avg_node_position
average node position
Definition: Actor.h:561
RoR::ActorPtr
RefCountingObjectPtr< Actor > ActorPtr
Definition: ForwardDeclarations.h:219
RoR::ActorLinkingRequest::alr_actor_instance_id
ActorInstanceID_t alr_actor_instance_id
Definition: SimData.h:906
RoR::MSG_SIM_DELETE_ACTOR_REQUESTED
@ MSG_SIM_DELETE_ACTOR_REQUESTED
Payload = RoR::ActorPtr* (owner)
Definition: Application.h:123
RoR::LT_AllBeam
@ LT_AllBeam
Definition: Application.h:320
ShouldIncludeActorInList
bool ShouldIncludeActorInList(const ActorPtr &actor)
Definition: ActorManager.cpp:936
RoR::ScriptCategory::ACTOR
@ ACTOR
Defined in truck file under 'scripts', contains global variable BeamClass@ thisActor.
RoR::ActorSpawnRequest::net_source_id
int net_source_id
Definition: SimData.h:844
RoR::ActorManager::UpdateTruckFeatures
void UpdateTruckFeatures(ActorPtr vehicle, float dt)
Definition: ActorManager.cpp:1423
RoR::ActorManager::ForwardCommands
void ForwardCommands(ActorPtr source_actor)
Fowards things to trailers.
Definition: ActorManager.cpp:655
Terrain.h
RoR::Actor::ar_net_stream_id
int ar_net_stream_id
Definition: Actor.h:426
RoR::Collisions::isInside
bool isInside(Ogre::Vector3 pos, const Ogre::String &inst, const Ogre::String &box, float border=0)
Definition: Collisions.cpp:1169
RoR::Actor::ar_submesh_ground_model
ground_model_t * ar_submesh_ground_model
Definition: Actor.h:410
RoR::ActorState::NETWORKED_HIDDEN
@ NETWORKED_HIDDEN
not simulated, not updated (remote)
BitMask_t
uint32_t BitMask_t
Definition: BitFlags.h:7
RoR::ActorManager::FetchActorDef
RigDef::DocumentPtr FetchActorDef(RoR::ActorSpawnRequest &rq)
Definition: ActorManager.cpp:1243
InputEngine.h
Handles controller inputs from player. Defines input events and binding mechanism,...
Ogre
Definition: ExtinguishableFireAffector.cpp:35
RoR::Actor::m_wheel_node_count
int m_wheel_node_count
Static attr; filled at spawn.
Definition: Actor.h:584
RoR::ActorSpawner::SetupDefaultSoundSources
static void SetupDefaultSoundSources(ActorPtr const &actor)
Definition: ActorSpawner.cpp:6310
RoR::ActorManager::RepairActor
void RepairActor(Collisions *collisions, const Ogre::String &inst, const Ogre::String &box, bool keepPosition=false)
Definition: ActorManager.cpp:828
RoR::ActorSpawnRequest::asr_net_peeropts
BitMask_t asr_net_peeropts
RoRnet::PeerOptions to be applied after spawn.
Definition: SimData.h:843
RigDef::DocumentPtr
std::shared_ptr< Document > DocumentPtr
Definition: ForwardDeclarations.h:272
RoR::Console::CONSOLE_SYSTEM_WARNING
@ CONSOLE_SYSTEM_WARNING
Definition: Console.h:53
RigDef::Validator::Validate
bool Validate()
Definition: RigDef_Validator.cpp:56
RoR::App::app_async_physics
CVar * app_async_physics
Definition: Application.cpp:83
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::CVar::getInt
int getInt() const
Definition: CVar.h:97
RoR::Console::CONSOLE_MSGTYPE_INFO
@ CONSOLE_MSGTYPE_INFO
Generic message.
Definition: Console.h:60
RoR::Actor::calculateAveragePosition
void calculateAveragePosition()
Definition: Actor.cpp:1077
RoR::ActorManager::m_forced_awake
bool m_forced_awake
disables sleep counters
Definition: ActorManager.h:146
RoR::FreeForceRequest::ffr_id
int64_t ffr_id
Definition: SimData.h:790
RoR::SS_TRIG_REPAIR
@ SS_TRIG_REPAIR
Definition: SoundScriptManager.h:67
RoR::ActorSpawnRequest::asr_position
Ogre::Vector3 asr_position
Definition: SimData.h:833
RoR::ActorSpawner::GetSubmeshGroundmodelName
std::string GetSubmeshGroundmodelName()
Definition: ActorSpawner.cpp:1318
RoR::ActorManager::WakeUpAllActors
void WakeUpAllActors()
Definition: ActorManager.cpp:785
RoR::Engine::getAutoShift
int getAutoShift()
Definition: Engine.cpp:1181
RoR::Actor::ar_net_source_id
int ar_net_source_id
Unique ID of remote player who spawned this actor.
Definition: Actor.h:425
Collisions.h
RoR::node_t::mass
Ogre::Real mass
Definition: SimData.h:298
RoR::EV_COMMON_RESET_SIMULATION_PACE
@ EV_COMMON_RESET_SIMULATION_PACE
reset the simulation speed
Definition: InputEngine.h:225
RoR::ActorState::NETWORKED_OK
@ NETWORKED_OK
not simulated (remote) actor
RoR::ThreadPool::Parallelize
void Parallelize(const std::vector< std::function< void()>> &task_funcs)
Run collection of tasks in parallel and wait until all have finished.
Definition: ThreadPool.h:193
RoR::App::GetThreadPool
ThreadPool * GetThreadPool()
Definition: Application.cpp:277
RoR::ActorManager::UpdateActors
void UpdateActors(ActorPtr player_actor)
Definition: ActorManager.cpp:1016
RoR::EV_COMMON_DECELERATE_SIMULATION
@ EV_COMMON_DECELERATE_SIMULATION
decelerate the simulation speed
Definition: InputEngine.h:224
RoR::tryConvertUTF
Ogre::UTFString tryConvertUTF(const char *buffer)
Definition: Utils.cpp:58
RoR::NetRecvPacket
Definition: Network.h:94
RoR::ActorLinkingRequestType::TIE_TOGGLE
@ TIE_TOGGLE
RoR::Actor::ar_state
ActorState ar_state
Definition: Actor.h:453
RoR::GfxActor::UpdateFlexbodies
void UpdateFlexbodies()
Definition: GfxActor.cpp:3191
RoR::ActorManager::FetchNextVehicleOnList
const ActorPtr & FetchNextVehicleOnList(ActorPtr player, ActorPtr prev_player)
Definition: ActorManager.cpp:952
RoR::Actor::getLightStateMask
BitMask_t getLightStateMask() const
Definition: Actor.h:187
RoR::GfxActor::UpdateWheelVisuals
void UpdateWheelVisuals()
Definition: GfxActor.cpp:1959
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
RoR::Engine::startEngine
void startEngine()
Quick engine start. Plays sounds.
Definition: Engine.cpp:995
RoR::ActorSpawner::GetMemoryRequirements
ActorMemoryRequirements const & GetMemoryRequirements()
Definition: ActorSpawner.h:107
RoR::FreeForce::ffc_target_coords
Ogre::Vector3 ffc_target_coords
Definition: SimData.h:779
RoR::TyrePressure::IsEnabled
bool IsEnabled() const
Definition: TyrePressure.h:47
RoR::Engine::getGear
int getGear()
Definition: Engine.cpp:1038
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_spawnbox
collision_box_t * asr_spawnbox
Definition: SimData.h:835
RoR::ActorSpawnRequest::asr_rotation
Ogre::Quaternion asr_rotation
Definition: SimData.h:834
RoR::FreeForceRequest::ffr_type
int64_t ffr_type
Definition: SimData.h:791
RoR::Actor::UpdateBoundingBoxes
void UpdateBoundingBoxes()
Definition: Actor.cpp:1112
RoR
Definition: AppContext.h:36
Network.h
RoR::ActorManager::GetActorById
const ActorPtr & GetActorById(ActorInstanceID_t actor_id)
Definition: ActorManager.cpp:1132
RoR::App::sim_spawn_running
CVar * sim_spawn_running
Definition: Application.cpp:100
RoR::ActorManager::m_free_forces
FreeForceVec_t m_free_forces
Global forces added ad-hoc by scripts.
Definition: ActorManager.h:154
RoR::beam_t::default_beam_deform
float default_beam_deform
for reset
Definition: SimData.h:361
RoR::ActorManager::CleanUpSimulation
void CleanUpSimulation()
Call this after simulation loop finishes.
Definition: ActorManager.cpp:858
RoR::App::GetGfxScene
GfxScene * GetGfxScene()
Definition: Application.cpp:279
RoR::GameContext::GetActorManager
ActorManager * GetActorManager()
Definition: GameContext.h:127
RoRnet::MSG2_USER_LEAVE
@ MSG2_USER_LEAVE
user leaves
Definition: RoRnet.h:58
RoR::Engine::getTorque
float getTorque()
Definition: Engine.cpp:913
RoR::ActorManager::CreateNewActor
ActorPtr CreateNewActor(ActorSpawnRequest rq, RigDef::DocumentPtr def)
Definition: ActorManager.cpp:78
RoR::Engine::NEUTRAL
@ NEUTRAL
Definition: Engine.h:170
RoR::FreeForceRequest::ffr_target_actor
int64_t ffr_target_actor
Definition: SimData.h:798
RoR::ActorManager::UpdatePhysicsSimulation
void UpdatePhysicsSimulation()
Definition: ActorManager.cpp:1144
RoR::App::sim_replay_enabled
CVar * sim_replay_enabled
Definition: Application.cpp:101
RoR::ActorManager::CheckNetRemoteStreamsOk
int CheckNetRemoteStreamsOk(int sourceid)
Definition: ActorManager.cpp:540
RoR::ActorModifyRequest::Type::RESET_ON_SPOT
@ RESET_ON_SPOT
RoR::App::mp_pseudo_collisions
CVar * mp_pseudo_collisions
Definition: Application.cpp:120
RoR::Actor::isBeingReset
bool isBeingReset() const
Definition: Actor.h:279
RoR::GameContext::GetTerrain
const TerrainPtr & GetTerrain()
Definition: GameContext.h:117
RoR::CacheEntry::fname
Ogre::String fname
filename
Definition: CacheSystem.h:67
RoR::Actor::calcNodeConnectivityGraph
void calcNodeConnectivityGraph()
Definition: Actor.cpp:818
RoRnet::StreamRegister
< Sent from the client to server and vice versa, to broadcast a new stream
Definition: RoRnet.h:148