mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-03-22 15:05:03 +01:00
754 lines
22 KiB
C++
754 lines
22 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "Classes.h"
|
|
#include "scene.h"
|
|
#include "Names.h"
|
|
#include "EvLaunch.h"
|
|
#include "Logs.h"
|
|
#include "command.h"
|
|
#include "comparison.h"
|
|
|
|
#ifdef WITH_LUA
|
|
#include "lua.h"
|
|
#endif
|
|
|
|
// common event interface
|
|
class basic_event {
|
|
|
|
public:
|
|
// types
|
|
enum flags {
|
|
// shared values
|
|
text = 1 << 0,
|
|
value1 = 1 << 1,
|
|
value2 = 1 << 2,
|
|
// update values
|
|
mode_add = 1 << 3,
|
|
// whois
|
|
mode_alt = 1 << 3,
|
|
whois_load = 1 << 4,
|
|
whois_name = 1 << 5,
|
|
// condition values
|
|
track_busy = 1 << 3,
|
|
track_free = 1 << 4,
|
|
probability = 1 << 5
|
|
};
|
|
// constructor
|
|
basic_event() = default;
|
|
// destructor
|
|
virtual ~basic_event();
|
|
// methods
|
|
// restores event data from provided stream
|
|
virtual
|
|
void
|
|
deserialize( cParser &Input, scene::scratch_data &Scratchpad );
|
|
// prepares event for use
|
|
virtual
|
|
void
|
|
init() = 0;
|
|
// executes event
|
|
virtual
|
|
void
|
|
run();
|
|
// sends basic content of the class in legacy (text) format to provided stream
|
|
virtual
|
|
void
|
|
export_as_text( std::ostream &Output ) const;
|
|
// adds a sibling event executed together
|
|
void
|
|
append( basic_event *Event );
|
|
// returns: true if the event should be executed immediately
|
|
virtual
|
|
bool
|
|
is_instant() const;
|
|
// sends content of associated data cell to specified vehicle controller
|
|
virtual
|
|
void
|
|
send_command( TController &Controller );
|
|
// returns: true if associated data cell contains a command for vehicle controller
|
|
virtual
|
|
bool
|
|
is_command() const;
|
|
// input data access
|
|
virtual std::string input_text() const;
|
|
virtual TCommandType input_command() const;
|
|
virtual double input_value( int Index ) const;
|
|
virtual glm::dvec3 input_location() const;
|
|
void group( scene::group_handle Group );
|
|
scene::group_handle group() const;
|
|
std::string const &name() const { return m_name; }
|
|
// members
|
|
basic_event *m_next { nullptr }; // następny w kolejce // TODO: replace with event list in the manager
|
|
basic_event *m_sibling { nullptr }; // kolejny event z tą samą nazwą - od wersji 378
|
|
std::string m_name;
|
|
bool m_ignored { false }; // replacement for tp_ignored
|
|
bool m_passive { false }; // false gdy ma nie być dodawany do kolejki (skanowanie sygnałów)
|
|
int m_inqueue { 0 }; // ile razy dodany do kolejki
|
|
TDynamicObject const *m_activator { nullptr };
|
|
double m_launchtime { 0.0 };
|
|
double m_delay { 0.0 };
|
|
double m_delayrandom { 0.0 }; // zakres dodatkowego opóźnienia // standardowo nie będzie dodatkowego losowego opóźnienia
|
|
double m_delaydeparture { std::numeric_limits<double>::quiet_NaN() }; // departure-based event delay
|
|
|
|
protected:
|
|
// types
|
|
using basic_node = std::tuple<std::string, scene::basic_node *>;
|
|
using node_sequence = std::vector<basic_node>;
|
|
|
|
struct event_conditions {
|
|
unsigned int flags { 0 };
|
|
float probability { 0.0 }; // used by conditional_probability
|
|
double memcompare_value1 { 0.0 }; // used by conditional_memcompare
|
|
double memcompare_value2 { 0.0 }; // used by conditional_memcompare
|
|
std::string memcompare_text; // used by conditional_memcompare
|
|
comparison_operator memcompare_value1_operator { comparison_operator::equal }; // used by conditional_memcompare
|
|
comparison_operator memcompare_value2_operator { comparison_operator::equal }; // used by conditional_memcompare
|
|
comparison_operator memcompare_text_operator { comparison_operator::equal }; // used by conditional_memcompare
|
|
comparison_pass memcompare_pass { comparison_pass::all }; // used by conditional_memcompare
|
|
basic_event::node_sequence *memcompare_cells; // used by conditional_memcompare
|
|
std::vector<TTrack *> tracks; // used by conditional_track
|
|
bool has_else { false };
|
|
|
|
void deserialize( cParser &Input );
|
|
void bind( basic_event::node_sequence *Nodes );
|
|
void init();
|
|
// verifies whether event meets execution condition(s)
|
|
bool test() const;
|
|
// sends basic content of the class in legacy (text) format to provided stream
|
|
void export_as_text( std::ostream &Output ) const;
|
|
};
|
|
// methods
|
|
template <class TableType_>
|
|
void init_targets( TableType_ &Repository, std::string const &Targettype, bool const Logerrors = true );
|
|
// returns true if provided token is a an event desription keyword, false otherwise
|
|
static bool is_keyword( std::string const &Token );
|
|
|
|
// members
|
|
node_sequence m_targets; // targets of operation performed when this event is executed
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
virtual std::string type() const = 0;
|
|
// deserialization helper, converts provided string to a list of target nodes
|
|
virtual void deserialize_targets( std::string const &Input );
|
|
// deserialize() subclass details
|
|
virtual void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) = 0;
|
|
// run() subclass details
|
|
virtual void run_() = 0;
|
|
// export_as_text() subclass details
|
|
virtual void export_as_text_( std::ostream &Output ) const = 0;
|
|
// members
|
|
scene::group_handle m_group { null_handle }; // group this event belongs to, if any
|
|
};
|
|
|
|
|
|
|
|
// specialized event, sends received input to its target(s)
|
|
// TBD: replace the generic module with specialized mixins
|
|
class input_event : public basic_event {
|
|
|
|
friend basic_event * make_event( cParser &Input, scene::scratch_data &Scratchpad );
|
|
|
|
protected:
|
|
// types
|
|
struct input_data {
|
|
unsigned int flags { 0 };
|
|
std::string data_text;
|
|
double data_value_1 { 0.0 };
|
|
double data_value_2 { 0.0 };
|
|
basic_node data_source { "", nullptr };
|
|
glm::dvec3 location { 0.0 };
|
|
TCommandType command_type { TCommandType::cm_Unknown };
|
|
|
|
TMemCell const * data_cell() const;
|
|
TMemCell * data_cell();
|
|
};
|
|
|
|
// members
|
|
input_data m_input;
|
|
};
|
|
|
|
|
|
|
|
class updatevalues_event : public input_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
// returns: true if the event should be executed immediately
|
|
bool is_instant() const override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
event_conditions m_conditions;
|
|
};
|
|
|
|
|
|
|
|
class copyvalues_event : public input_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
};
|
|
|
|
|
|
|
|
class getvalues_event : public input_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
// sends content of associated data cell to specified vehicle controller
|
|
void send_command( TController &Controller ) override;
|
|
// returns: true if associated data cell contains a command for vehicle controller
|
|
bool is_command() const override;
|
|
// input data access
|
|
std::string input_text() const override;
|
|
TCommandType input_command() const override;
|
|
double input_value( int Index ) const override;
|
|
glm::dvec3 input_location() const override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
};
|
|
|
|
|
|
|
|
class putvalues_event : public input_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
// input data access
|
|
std::string input_text() const override;
|
|
TCommandType input_command() const override;
|
|
double input_value( int Index ) const override;
|
|
glm::dvec3 input_location() const override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
//determines whether provided input should be passed to consist owner
|
|
bool is_command_for_owner( input_data const &Input ) const;
|
|
};
|
|
|
|
|
|
|
|
class whois_event : public input_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
};
|
|
|
|
|
|
|
|
class logvalues_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
};
|
|
|
|
|
|
|
|
class multi_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
std::vector<std::string> dump_children_names() const;
|
|
|
|
private:
|
|
// types
|
|
// wrapper for binding between editor-supplied name, event, and execution conditional flag
|
|
using conditional_event = std::tuple<std::string, basic_event *, bool>;
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
std::vector<conditional_event> m_children; // events which are placed in the query when this event is executed
|
|
event_conditions m_conditions;
|
|
};
|
|
|
|
|
|
|
|
class sound_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// types
|
|
// wrapper for binding between editor-supplied name and sound object
|
|
using basic_sound = std::tuple<std::string, sound_source *>;
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialization helper, converts provided string to a list of target nodes
|
|
void deserialize_targets( std::string const &Input ) override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
std::vector<basic_sound> m_sounds;
|
|
int m_soundmode{ 0 };
|
|
int m_soundradiochannel{ 0 };
|
|
};
|
|
|
|
|
|
|
|
// assigns a texture as specified replacable skin to a list of specified scene model nodes
|
|
// skin filename is built dynamically using specified expression and list of parameters from optional specified memory cell
|
|
class texture_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// types
|
|
struct input_data {
|
|
basic_node data_source { "", nullptr };
|
|
|
|
TMemCell const * data_cell() const;
|
|
TMemCell * data_cell();
|
|
};
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
int m_skinindex { 0 }; // index of target replacable skin
|
|
std::string m_skin; // expression defining skin filename
|
|
input_data m_input; // optional source of expression parameters
|
|
};
|
|
|
|
|
|
|
|
class animation_event : public basic_event {
|
|
|
|
public:
|
|
// destuctor
|
|
~animation_event() override;
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
int m_animationtype{ 0 };
|
|
std::array<double, 4> m_animationparams{ 0.0 };
|
|
std::string m_animationsubmodel;
|
|
std::list<std::weak_ptr<TAnimContainer>> m_animationcontainers;
|
|
std::string m_animationfilename;
|
|
std::size_t m_animationfilesize{ 0 };
|
|
char *m_animationfiledata{ nullptr };
|
|
};
|
|
|
|
|
|
|
|
class lights_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
std::vector<float> m_lights;
|
|
};
|
|
|
|
|
|
|
|
class switch_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
int m_switchstate{ 0 };
|
|
float m_switchmoverate{ -1.f };
|
|
float m_switchmovedelay{ -1.f };
|
|
};
|
|
|
|
|
|
|
|
class track_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
float m_velocity{ 0.f };
|
|
};
|
|
|
|
|
|
|
|
class voltage_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
float m_voltage{ -1.f };
|
|
};
|
|
|
|
|
|
|
|
class visible_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
bool m_visible{ true };
|
|
};
|
|
|
|
|
|
|
|
class friction_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
float m_friction{ -1.f };
|
|
};
|
|
|
|
#ifdef WITH_LUA
|
|
class lua_event : public basic_event {
|
|
public:
|
|
lua_event(lua::eventhandler_t func);
|
|
void init() override;
|
|
|
|
private:
|
|
std::string type() const override;
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
void run_() override;
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
bool is_instant() const override;
|
|
|
|
lua::eventhandler_t lua_func = nullptr;
|
|
};
|
|
#endif
|
|
|
|
class message_event : public basic_event {
|
|
|
|
public:
|
|
// methods
|
|
// prepares event for use
|
|
void init() override;
|
|
|
|
private:
|
|
// methods
|
|
// event type string
|
|
std::string type() const override;
|
|
// deserialize() subclass details
|
|
void deserialize_( cParser &Input, scene::scratch_data &Scratchpad ) override;
|
|
// run() subclass details
|
|
void run_() override;
|
|
// export_as_text() subclass details
|
|
void export_as_text_( std::ostream &Output ) const override;
|
|
// members
|
|
std::string m_message;
|
|
};
|
|
|
|
|
|
|
|
basic_event *
|
|
make_event( cParser &Input, scene::scratch_data &Scratchpad );
|
|
|
|
|
|
|
|
class event_manager {
|
|
|
|
public:
|
|
// constructors
|
|
event_manager() = default;
|
|
// destructor
|
|
~event_manager();
|
|
// methods
|
|
// adds specified event launcher to the list of global launchers
|
|
void
|
|
queue( TEventLauncher *Launcher );
|
|
// inserts in the event query events assigned to event launchers capable of receiving specified radio message sent from specified location
|
|
void
|
|
queue_receivers( radio_message const Message, glm::dvec3 const &Location );
|
|
// legacy method, updates event queues
|
|
void
|
|
update();
|
|
// adds provided event to the collection. returns: true on success
|
|
// TBD, TODO: return handle to the event
|
|
bool
|
|
insert( basic_event *Event );
|
|
inline
|
|
bool
|
|
insert( TEventLauncher *Launcher ) {
|
|
return (
|
|
Launcher->IsRadioActivated() ?
|
|
m_radiodrivenlaunchers.insert( Launcher ) :
|
|
m_inputdrivenlaunchers.insert( Launcher ) ); }
|
|
inline void purge (TEventLauncher *Launcher) {
|
|
m_radiodrivenlaunchers.purge(Launcher);
|
|
m_inputdrivenlaunchers.purge(Launcher); }
|
|
// returns first event in the queue
|
|
inline
|
|
basic_event *
|
|
begin() {
|
|
return QueryRootEvent; }
|
|
|
|
basic_event*
|
|
FindEventById(uint32_t id);
|
|
uint32_t GetEventId(const basic_event *ev);
|
|
uint32_t GetEventId(std::string const &Name);
|
|
|
|
// legacy method, returns pointer to specified event, or null
|
|
basic_event *
|
|
FindEvent( std::string const &Name );
|
|
inline TEventLauncher* FindEventlauncher(std::string const &Name) {
|
|
auto ptr = m_inputdrivenlaunchers.find(Name);
|
|
return ptr ? ptr : m_radiodrivenlaunchers.find(Name);
|
|
}
|
|
// legacy method, inserts specified event in the event query
|
|
bool
|
|
AddToQuery( basic_event *Event, TDynamicObject const *Owner, double delay = 0.0 );
|
|
// legacy method, executes queued events
|
|
bool
|
|
CheckQuery();
|
|
// legacy method, initializes events after deserialization from scenario file
|
|
void
|
|
InitEvents();
|
|
// legacy method, initializes event launchers after deserialization from scenario file
|
|
void
|
|
InitLaunchers();
|
|
// sends basic content of the class in legacy (text) format to provided stream
|
|
void
|
|
export_as_text( std::ostream &Output ) const;
|
|
// returns all eventlaunchers in radius ignoring height
|
|
std::vector<TEventLauncher *>
|
|
find_eventlaunchers(glm::vec2 center, float radius) const;
|
|
|
|
private:
|
|
// types
|
|
using event_sequence = std::deque<basic_event *>;
|
|
using event_map = std::unordered_map<std::string, std::size_t>;
|
|
using eventlauncher_sequence = std::vector<TEventLauncher *>;
|
|
// members
|
|
event_sequence m_events;
|
|
/*
|
|
// NOTE: disabled until event class refactoring
|
|
event_sequence m_eventqueue;
|
|
*/
|
|
// legacy version of the above
|
|
basic_event *QueryRootEvent { nullptr };
|
|
basic_event *m_workevent { nullptr };
|
|
event_map m_eventmap;
|
|
basic_table<TEventLauncher> m_inputdrivenlaunchers;
|
|
basic_table<TEventLauncher> m_radiodrivenlaunchers;
|
|
eventlauncher_sequence m_launcherqueue;
|
|
command_relay m_relay;
|
|
};
|
|
|
|
|
|
|
|
inline
|
|
void
|
|
basic_event::group( scene::group_handle Group ) {
|
|
m_group = Group;
|
|
}
|
|
|
|
inline
|
|
scene::group_handle
|
|
basic_event::group() const {
|
|
return m_group;
|
|
}
|
|
|
|
template <class TableType_>
|
|
void
|
|
basic_event::init_targets( TableType_ &Repository, std::string const &Targettype, bool const Logerrors ) {
|
|
|
|
for( auto &target : m_targets ) {
|
|
std::get<scene::basic_node *>( target ) = Repository.find( std::get<std::string>( target ) );
|
|
if( std::get<scene::basic_node *>( target ) == nullptr ) {
|
|
m_ignored = true; // deaktywacja
|
|
if( Logerrors )
|
|
ErrorLog( "Bad event: \"" + m_name + "\" (type: " + type() + ") can't find " + Targettype +" \"" + std::get<std::string>( target ) + "\"" );
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|