mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-28 13:47:58 +03:00
418 lines
9.9 KiB
C++
418 lines
9.9 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 2015 the OpenMoHAA team
|
|
|
|
This file is part of OpenMoHAA source code.
|
|
|
|
OpenMoHAA source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
OpenMoHAA source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenMoHAA source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
// characterstate.h: Character state
|
|
|
|
#ifndef __CHARACTERSTATE_H__
|
|
#define __CHARACTERSTATE_H__
|
|
|
|
#include "g_local.h"
|
|
#include "entity.h"
|
|
#include "script.h"
|
|
|
|
enum testcondition_t
|
|
{
|
|
TC_ISTRUE, // no prefix
|
|
TC_ISFALSE, // !
|
|
TC_EDGETRUE, // +
|
|
TC_EDGEFALSE // -
|
|
};
|
|
|
|
enum movecontrol_t
|
|
{
|
|
MOVECONTROL_NONE,
|
|
MOVECONTROL_USER, // Quake style
|
|
MOVECONTROL_LEGS, // Quake style, legs state system active
|
|
MOVECONTROL_USER_MOVEANIM,
|
|
MOVECONTROL_ANIM, // move based on animation, with full collision testing
|
|
MOVECONTROL_ABSOLUTE, // move based on animation, with full collision testing but no turning
|
|
MOVECONTROL_HANGING, // move based on animation, with full collision testing, hanging
|
|
MOVECONTROL_ROPE_GRAB,
|
|
MOVECONTROL_ROPE_RELEASE,
|
|
MOVECONTROL_ROPE_MOVE,
|
|
MOVECONTROL_PICKUPENEMY,
|
|
MOVECONTROL_PUSH,
|
|
MOVECONTROL_CLIMBWALL,
|
|
MOVECONTROL_USEANIM,
|
|
MOVECONTROL_CROUCH,
|
|
MOVECONTROL_LOOPUSEANIM,
|
|
MOVECONTROL_USEOBJECT,
|
|
MOVECONTROL_COOLOBJECT,
|
|
};
|
|
|
|
enum cameratype_t
|
|
{
|
|
CAMERA_TOPDOWN,
|
|
CAMERA_BEHIND,
|
|
CAMERA_FRONT,
|
|
CAMERA_SIDE,
|
|
CAMERA_BEHIND_FIXED,
|
|
CAMERA_SIDE_LEFT,
|
|
CAMERA_SIDE_RIGHT,
|
|
CAMERA_BEHIND_NOPITCH
|
|
};
|
|
|
|
#define DEFAULT_MOVETYPE MOVECONTROL_NONE
|
|
#define DEFAULT_CAMERA CAMERA_BEHIND
|
|
|
|
class Conditional;
|
|
|
|
template< class Type >
|
|
struct Condition
|
|
{
|
|
const char *name;
|
|
qboolean ( Type::*func )( Conditional &condition );
|
|
};
|
|
|
|
class Conditional : public Class
|
|
{
|
|
private :
|
|
qboolean result;
|
|
qboolean previous_result;
|
|
bool checked;
|
|
|
|
public :
|
|
CLASS_PROTOTYPE( Conditional );
|
|
|
|
Condition<Class> condition;
|
|
Container<str> parmList;
|
|
|
|
bool getResult( testcondition_t test, Entity &ent );
|
|
const char *getName( void );
|
|
|
|
Conditional( Condition<Class> &condition );
|
|
Conditional();
|
|
|
|
const char *getParm( int number );
|
|
void addParm( str parm );
|
|
int numParms( void );
|
|
void clearCheck( void );
|
|
void clearPrevious( void );
|
|
};
|
|
|
|
inline void Conditional::addParm
|
|
(
|
|
str parm
|
|
)
|
|
|
|
{
|
|
parmList.AddObject( parm );
|
|
}
|
|
|
|
inline const char *Conditional::getParm
|
|
(
|
|
int number
|
|
)
|
|
|
|
{
|
|
if ( ( number < 1 ) || ( number > parmList.NumObjects() ) )
|
|
{
|
|
gi.Error( ERR_DROP, "Parm #%d out of range on %s condition\n", number, condition.name );
|
|
}
|
|
return parmList.ObjectAt( number ).c_str();
|
|
}
|
|
|
|
inline int Conditional::numParms
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return parmList.NumObjects();
|
|
}
|
|
|
|
inline void Conditional::clearCheck
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
checked = false;
|
|
}
|
|
|
|
inline void Conditional::clearPrevious
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
previous_result = 0;
|
|
}
|
|
|
|
inline const char *Conditional::getName
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return condition.name;
|
|
}
|
|
|
|
inline bool Conditional::getResult
|
|
(
|
|
testcondition_t test,
|
|
Entity &ent
|
|
)
|
|
{
|
|
if ( condition.func && !checked )
|
|
{
|
|
checked = true;
|
|
previous_result = result;
|
|
|
|
result = ( ent.*condition.func )( *this );
|
|
}
|
|
|
|
switch( test )
|
|
{
|
|
case TC_ISFALSE :
|
|
return !result;
|
|
|
|
case TC_EDGETRUE:
|
|
return result && !previous_result;
|
|
|
|
case TC_EDGEFALSE:
|
|
return !result && previous_result;
|
|
|
|
case TC_ISTRUE :
|
|
default:
|
|
return result != false;
|
|
}
|
|
}
|
|
|
|
class State;
|
|
class StateMap;
|
|
|
|
class Expression : public Class
|
|
{
|
|
private :
|
|
struct condition_t
|
|
{
|
|
testcondition_t test;
|
|
int condition_index;
|
|
};
|
|
|
|
str value;
|
|
Container<condition_t> conditions;
|
|
|
|
public :
|
|
Expression();
|
|
Expression( Expression &exp );
|
|
Expression( Script &script, State &state );
|
|
|
|
void operator=( const Expression &exp );
|
|
|
|
bool getResult( State &state, Entity &ent, Container<Conditional *> *sent_conditionals );
|
|
const char *getValue( void );
|
|
};
|
|
|
|
inline void Expression::operator=
|
|
(
|
|
const Expression &exp
|
|
)
|
|
|
|
{
|
|
int i;
|
|
|
|
value = exp.value;
|
|
|
|
conditions.FreeObjectList();
|
|
for( i = 1; i <= exp.conditions.NumObjects(); i++ )
|
|
{
|
|
conditions.AddObject( exp.conditions.ObjectAt( i ) );
|
|
}
|
|
}
|
|
|
|
inline const char *Expression::getValue
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return value.c_str();
|
|
}
|
|
|
|
class State : public Class
|
|
{
|
|
private :
|
|
Container<int> condition_indexes;
|
|
|
|
StateMap &statemap;
|
|
|
|
str name;
|
|
|
|
str nextState;
|
|
movecontrol_t movetype;
|
|
cameratype_t cameratype;
|
|
|
|
str behaviorName;
|
|
Container<str> behaviorParmList;
|
|
|
|
float minTime;
|
|
float maxTime;
|
|
|
|
Container<Expression> legAnims;
|
|
Container<Expression> m_actionAnims;
|
|
int m_iActionAnimType;
|
|
|
|
Container<Expression> states;
|
|
Container<str> entryCommands;
|
|
Container<str> exitCommands;
|
|
|
|
void readNextState( Script &script );
|
|
void readMoveType( Script &script );
|
|
void readCamera( Script &script );
|
|
void readLegs( Script &script );
|
|
void readAction( Script &script );
|
|
void readBehavior( Script &script );
|
|
void readTime( Script &script );
|
|
void readStates( Script &script );
|
|
void readCommands( Script &script, Container<str> &container );
|
|
|
|
void ParseAndProcessCommand( str command, Entity *target );
|
|
|
|
public :
|
|
State( const char *name, Script &script, StateMap &map );
|
|
|
|
State *Evaluate( Entity &ent, Container<Conditional *> *ent_conditionals );
|
|
int addCondition( const char *name, Script &script );
|
|
void CheckStates( void );
|
|
|
|
const char *getName( void );
|
|
|
|
const char *getLegAnim( Entity &ent, Container<Conditional *> *sent_conditionals );
|
|
const char *getActionAnim( Entity &ent, Container<Conditional *> *sent_conditionals, int *piAnimType = NULL );
|
|
const char *getBehaviorName( void );
|
|
State *getNextState( void );
|
|
movecontrol_t getMoveType( void );
|
|
cameratype_t getCameraType( void );
|
|
qboolean setCameraType( str ctype );
|
|
|
|
const char *getBehaviorParm( int number=1 );
|
|
void addBehaviorParm( str parm );
|
|
int numBehaviorParms( void );
|
|
|
|
float getMinTime( void );
|
|
float getMaxTime( void );
|
|
void ProcessEntryCommands( Entity *target );
|
|
void ProcessExitCommands( Entity *target );
|
|
void GetLegAnims( Container<const char *> *c );
|
|
void GetActionAnims( Container<const char *> *c );
|
|
};
|
|
|
|
inline void State::addBehaviorParm
|
|
(
|
|
str parm
|
|
)
|
|
|
|
{
|
|
behaviorParmList.AddObject( parm );
|
|
}
|
|
|
|
inline const char *State::getBehaviorParm
|
|
(
|
|
int number
|
|
)
|
|
|
|
{
|
|
return behaviorParmList.ObjectAt( number ).c_str();
|
|
}
|
|
|
|
inline int State::numBehaviorParms
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return behaviorParmList.NumObjects();
|
|
}
|
|
|
|
class StateMap : public Class
|
|
{
|
|
private :
|
|
Container<State *> stateList;
|
|
Condition<Class> *current_conditions;
|
|
Container<Conditional *> *current_conditionals;
|
|
str filename;
|
|
|
|
public :
|
|
StateMap( const char *filename, Condition<Class> *conditions, Container<Conditional *> *conditionals );
|
|
~StateMap();
|
|
|
|
Condition<Class> *getCondition( const char *name );
|
|
int findConditional( Conditional *condition );
|
|
int addConditional( Conditional *condition );
|
|
Conditional *getConditional( const char *name );
|
|
void GetAllAnims( Container<const char *> *c );
|
|
State *FindState( const char *name );
|
|
const char *Filename();
|
|
};
|
|
|
|
inline const char *StateMap::Filename
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return filename.c_str();
|
|
}
|
|
|
|
inline const char *State::getName
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return name.c_str();
|
|
}
|
|
|
|
inline State *State::getNextState
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return statemap.FindState( nextState.c_str() );
|
|
}
|
|
|
|
inline movecontrol_t State::getMoveType
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return movetype;
|
|
}
|
|
|
|
inline cameratype_t State::getCameraType
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return cameratype;
|
|
}
|
|
|
|
void ClearCachedStatemaps( void );
|
|
StateMap *GetStatemap( str filename, Condition<Class> *conditions, Container<Conditional *> *conditionals, qboolean reload, qboolean cache_only = false );
|
|
void CacheStatemap( str filename, Condition<Class> *conditions );
|
|
|
|
#endif /* !__CHARACTERSTATE_H__ */
|