2006-11-24 20:45:04 +01:00
|
|
|
//========================================================
|
|
|
|
//Description: Manages loading trigger specs (format in Atlas) and updating trigger objects
|
|
|
|
//=======================================================
|
|
|
|
|
2007-05-07 18:33:24 +02:00
|
|
|
#ifndef INCLUDED_TRIGGERMANAGER
|
|
|
|
#define INCLUDED_TRIGGERMANAGER
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
#include "ps/Singleton.h"
|
|
|
|
#include "scripting/ScriptableObject.h"
|
|
|
|
#include "simulation/ScriptObject.h"
|
|
|
|
|
2006-11-30 00:37:10 +01:00
|
|
|
#include <list>
|
|
|
|
#include <set>
|
|
|
|
|
2006-11-24 20:45:04 +01:00
|
|
|
class CXeromyces;
|
|
|
|
class XMBElement;
|
|
|
|
|
|
|
|
//Trigger storage - used be Atlas to keep track of different triggers
|
|
|
|
|
|
|
|
struct MapTriggerCondition
|
|
|
|
{
|
2006-11-30 00:37:10 +01:00
|
|
|
MapTriggerCondition() : linkLogic(0), negated(false) { }
|
2006-11-24 20:45:04 +01:00
|
|
|
CStrW name, functionName, displayName;
|
|
|
|
std::list<CStrW> parameters;
|
|
|
|
int linkLogic; //0 = NONE, 1 = AND, 2 = OR
|
2006-11-30 00:37:10 +01:00
|
|
|
bool negated;
|
2006-11-24 20:45:04 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct MapTriggerEffect
|
|
|
|
{
|
|
|
|
CStrW name, functionName, displayName;
|
|
|
|
std::list<CStrW> parameters;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MapTriggerLogicBlock
|
|
|
|
{
|
2006-11-30 00:37:10 +01:00
|
|
|
MapTriggerLogicBlock(size_t i, bool _not=false) : index(i), negated(_not) { }
|
2006-11-24 20:45:04 +01:00
|
|
|
size_t index;
|
2006-11-30 00:37:10 +01:00
|
|
|
bool negated;
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
bool operator< (const MapTriggerLogicBlock& block) const { return (index < block.index); }
|
|
|
|
bool operator== (const MapTriggerLogicBlock& block) const { return (index == block.index); }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MapTrigger
|
|
|
|
{
|
|
|
|
MapTrigger() : active(false), maxRunCount(0), timeValue(0) { }
|
|
|
|
bool active;
|
|
|
|
int maxRunCount;
|
|
|
|
float timeValue;
|
|
|
|
CStrW name, groupName;
|
|
|
|
|
|
|
|
std::set<MapTriggerLogicBlock> logicBlocks; //Indices of where "(" 's go before
|
|
|
|
std::set<size_t> logicBlockEnds; //Indices of where ")" 's come after
|
|
|
|
std::list<MapTriggerCondition> conditions;
|
|
|
|
std::list<MapTriggerEffect> effects;
|
|
|
|
|
2006-11-30 00:37:10 +01:00
|
|
|
void AddLogicBlock(bool negated) { logicBlocks.insert( MapTriggerLogicBlock(conditions.size(), negated) ); }
|
2006-11-24 20:45:04 +01:00
|
|
|
void AddLogicBlockEnd() { logicBlockEnds.insert( effects.size() ); }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MapTriggerGroup
|
|
|
|
{
|
|
|
|
MapTriggerGroup() { }
|
2008-07-12 12:45:11 +02:00
|
|
|
MapTriggerGroup(const CStrW& _name, const CStrW& _parentName) : name(_name), parentName(_parentName) {}
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
std::list<MapTrigger> triggers;
|
|
|
|
std::list<CStrW> childGroups; //Indices of children
|
|
|
|
CStrW name, parentName;
|
|
|
|
|
|
|
|
bool operator== (const CStrW& _name) const { return (name == _name); }
|
|
|
|
bool operator== (const MapTriggerGroup& group) const { return (name == group.name); }
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-05-02 14:07:08 +02:00
|
|
|
struct CopyIfRootChild
|
2006-11-24 20:45:04 +01:00
|
|
|
{
|
2007-05-02 14:07:08 +02:00
|
|
|
CopyIfRootChild(std::list<MapTriggerGroup>& groupList) : m_groupList(groupList) {}
|
2006-11-24 20:45:04 +01:00
|
|
|
void operator() ( const MapTriggerGroup& group )
|
|
|
|
{
|
|
|
|
if ( group.parentName == L"Triggers" )
|
|
|
|
m_groupList.push_back(group);
|
|
|
|
}
|
|
|
|
private:
|
2007-05-02 14:07:08 +02:00
|
|
|
void operator= (const CopyIfRootChild& UNUSED(group)) const {}
|
2006-11-24 20:45:04 +01:00
|
|
|
std::list<MapTriggerGroup>& m_groupList;
|
|
|
|
};
|
|
|
|
|
|
|
|
//Triggers used by engine
|
|
|
|
|
|
|
|
class CTrigger : public CJSObject<CTrigger>
|
|
|
|
{
|
|
|
|
int m_runCount;
|
|
|
|
CStrW m_conditionFuncString, m_effectFuncString, m_name, m_groupName;
|
|
|
|
CScriptObject m_effectFunction;
|
|
|
|
CScriptObject m_conditionFunction;
|
|
|
|
|
|
|
|
public:
|
|
|
|
CTrigger();
|
|
|
|
CTrigger(const CStrW& name, bool active, float delay, int maxRuns, const CStrW& condFunc,
|
|
|
|
const CStrW& effectFunc);
|
|
|
|
CTrigger(const CStrW& name, bool active, float delay, int maxRuns,
|
|
|
|
CScriptObject& condFunc, CScriptObject& effectFunc);
|
|
|
|
|
|
|
|
CTrigger& operator= (const CTrigger& trigger);
|
|
|
|
~CTrigger();
|
|
|
|
|
|
|
|
void SetFunctionBody(const CStrW& body);
|
|
|
|
const CStrW& GetConditionString() { return m_conditionFuncString; }
|
|
|
|
const CStrW& GetEffectString() { return m_effectFuncString; }
|
|
|
|
const CStrW& GetName() { return m_name; }
|
|
|
|
const CStrW& GetGroupName() { return m_groupName; }
|
|
|
|
|
|
|
|
bool ShouldFire();
|
|
|
|
//Returns false if trigger exceeds run count
|
|
|
|
bool Fire();
|
|
|
|
|
had to remove uint and ulong from lib/types.h due to conflict with other library.
this snowballed into a massive search+destroy of the hodgepodge of
mostly equivalent types we had in use (int, uint, unsigned, unsigned
int, i32, u32, ulong, uintN).
it is more efficient to use 64-bit types in 64-bit mode, so the
preferred default is size_t (for anything remotely resembling a size or
index). tile coordinates are ssize_t to allow more efficient conversion
to/from floating point. flags are int because we almost never need more
than 15 distinct bits, bit test/set is not slower and int is fastest to
type. finally, some data that is pretty much directly passed to OpenGL
is now typed accordingly.
after several hours, the code now requires fewer casts and less
guesswork.
other changes:
- unit and player IDs now have an "invalid id" constant in the
respective class to avoid casting and -1
- fix some endian/64-bit bugs in the map (un)packing. added a
convenience function to write/read a size_t.
- ia32: change CPUID interface to allow passing in ecx (required for
cache topology detection, which I need at work). remove some unneeded
functions from asm, replace with intrinsics where possible.
This was SVN commit r5942.
2008-05-11 20:48:32 +02:00
|
|
|
void Activate(JSContext* cx, uintN argc, jsval* argv);
|
|
|
|
void Deactivate(JSContext* cx, uintN argc, jsval* argv);
|
2006-11-24 20:45:04 +01:00
|
|
|
|
had to remove uint and ulong from lib/types.h due to conflict with other library.
this snowballed into a massive search+destroy of the hodgepodge of
mostly equivalent types we had in use (int, uint, unsigned, unsigned
int, i32, u32, ulong, uintN).
it is more efficient to use 64-bit types in 64-bit mode, so the
preferred default is size_t (for anything remotely resembling a size or
index). tile coordinates are ssize_t to allow more efficient conversion
to/from floating point. flags are int because we almost never need more
than 15 distinct bits, bit test/set is not slower and int is fastest to
type. finally, some data that is pretty much directly passed to OpenGL
is now typed accordingly.
after several hours, the code now requires fewer casts and less
guesswork.
other changes:
- unit and player IDs now have an "invalid id" constant in the
respective class to avoid casting and -1
- fix some endian/64-bit bugs in the map (un)packing. added a
convenience function to write/read a size_t.
- ia32: change CPUID interface to allow passing in ecx (required for
cache topology detection, which I need at work). remove some unneeded
functions from asm, replace with intrinsics where possible.
This was SVN commit r5942.
2008-05-11 20:48:32 +02:00
|
|
|
static JSBool Construct( JSContext* cx, JSObject* obj, uintN argc, jsval* argv, jsval* rval );
|
2006-11-24 20:45:04 +01:00
|
|
|
static void ScriptingInit();
|
|
|
|
|
|
|
|
JSContext* m_cx;
|
|
|
|
|
|
|
|
bool m_active;
|
|
|
|
//Changeable by Atlas or needed by manager, no additional affects required
|
|
|
|
int m_maxRunCount;
|
|
|
|
float m_timeLeft, m_timeDelay;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//*****Holds information specifying how conditions and effects should look like in atlas******
|
|
|
|
|
|
|
|
struct TriggerParameter
|
|
|
|
{
|
|
|
|
TriggerParameter() {}
|
|
|
|
TriggerParameter(int _row, int _column) : row(_row), column(_column) {}
|
|
|
|
void SetWindowData(const CStrW& _windowType, CStrW& windowPosition, CStrW& windowSize);
|
|
|
|
//Sort parameters in the order they will be added to a sizer in atlas
|
|
|
|
bool operator< ( const TriggerParameter& rhs ) const;
|
2007-01-17 00:22:25 +01:00
|
|
|
bool operator< ( const int parameter ) const { return parameterOrder < parameter; }
|
|
|
|
bool operator== ( const int parameter ) const { return parameterOrder == parameter; }
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
CStrW name, windowType, inputType;
|
|
|
|
int row, column, xPos, yPos, xSize, ySize, parameterOrder;
|
|
|
|
};
|
|
|
|
|
|
|
|
class CTriggerSpec
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
CTriggerSpec() {}
|
|
|
|
~CTriggerSpec() {}
|
|
|
|
|
|
|
|
void AddParameter(const TriggerParameter& param) { parameters.insert(param); }
|
|
|
|
const std::set<TriggerParameter>& GetParameters() const { return parameters; }
|
|
|
|
|
2007-01-17 00:22:25 +01:00
|
|
|
int funcParameters;
|
2006-11-24 20:45:04 +01:00
|
|
|
CStrW displayName, functionName;
|
|
|
|
|
2007-01-17 00:22:25 +01:00
|
|
|
bool operator== (const std::wstring& display) const { return display == displayName; }
|
|
|
|
|
2006-11-24 20:45:04 +01:00
|
|
|
private:
|
|
|
|
|
|
|
|
//Sorted by parameter order to make things easy for Atlas
|
|
|
|
std::set<TriggerParameter> parameters;
|
|
|
|
};
|
|
|
|
typedef CTriggerSpec CTriggerEffect;
|
|
|
|
typedef CTriggerSpec CTriggerCondition;
|
|
|
|
|
|
|
|
|
|
|
|
/******************************Trigger manager******************************/
|
|
|
|
|
|
|
|
class CTriggerManager : public Singleton<CTriggerManager>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef std::map<CStrW, CTrigger*>::iterator TriggerIter ;
|
|
|
|
|
|
|
|
CTriggerManager();
|
|
|
|
~CTriggerManager();
|
|
|
|
|
|
|
|
//Returns false on detection of error
|
2007-05-02 14:07:08 +02:00
|
|
|
bool LoadXml( const CStr& filename );
|
2006-11-24 20:45:04 +01:00
|
|
|
void Update(float delta);
|
|
|
|
|
|
|
|
//Add simulation trigger (probably only called from JS)
|
|
|
|
void AddTrigger(CTrigger* trigger);
|
|
|
|
void AddTrigger(MapTriggerGroup& group, const MapTrigger& trigger);
|
|
|
|
void AddGroup(const MapTriggerGroup& group);
|
|
|
|
void SetAllGroups(const std::list<MapTriggerGroup>& groups);
|
|
|
|
void DestroyEngineTriggers();
|
|
|
|
|
|
|
|
const std::list<CTriggerCondition>& GetAllConditions() const { return m_ConditionSpecs; }
|
|
|
|
const std::list<CTriggerEffect>& GetAllEffects() const { return m_EffectSpecs; }
|
|
|
|
const std::list<MapTriggerGroup>& GetAllTriggerGroups() const { return m_GroupList; }
|
|
|
|
std::vector<std::wstring> GetTriggerChoices(const std::wstring& name);
|
2007-01-17 00:22:25 +01:00
|
|
|
std::vector<std::wstring> GetTriggerTranslations(const std::wstring& name);
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
std::map<CStrW, CTrigger*> m_TriggerMap; //Simulation triggers - used in engine
|
|
|
|
|
|
|
|
private:
|
2007-05-02 14:07:08 +02:00
|
|
|
bool LoadTriggerSpec( XMBElement condition, CXeromyces& XeroFile, bool isCondition );
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
//Contains choices for trigger choice box parameters, with key = spec.funcName+paramName
|
|
|
|
std::map<std::wstring, std::vector<std::wstring> > m_TriggerChoices;
|
2007-01-17 00:22:25 +01:00
|
|
|
std::map<std::wstring, std::vector<std::wstring> > m_TriggerTranslations;
|
2006-11-24 20:45:04 +01:00
|
|
|
|
|
|
|
//Holds information which descibes trigger layout in atlas
|
|
|
|
std::list<MapTriggerGroup> m_GroupList;
|
|
|
|
std::list<CTriggerCondition> m_ConditionSpecs;
|
|
|
|
std::list<CTriggerEffect> m_EffectSpecs;
|
|
|
|
|
2007-01-17 00:22:25 +01:00
|
|
|
float m_UpdateRate; //TODO: Get this from a config setting
|
|
|
|
float m_UpdateTime;
|
|
|
|
|
2006-11-24 20:45:04 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define g_TriggerManager CTriggerManager::GetSingleton()
|
|
|
|
|
2007-05-07 18:33:24 +02:00
|
|
|
#endif //ifndef INCLUDED_TRIGGERMANAGER
|