Added typeinfogen with state system

2026-08-20 04:30:12 +02:00 · 2026-05-18 21:35:07 -07:00
parent 4686349b62
commit b841fcb33b
27 changed files with 21899 additions and 194 deletions
@@ -0,0 +1,168 @@
+#ifndef __SYS_STATE_H__
+#define __SYS_STATE_H__
+
+typedef enum
+{
+	SRESULT_OK,				// Call was made successfully
+	SRESULT_ERROR,			// An unrecoverable error occurred
+	SRESULT_DONE,			// Done with current state, move to next
+	SRESULT_DONE_WAIT,		// Done with current state, wait a frame then move to next
+	SRESULT_WAIT,			// Wait a frame and re-run current state
+	SRESULT_IDLE,			// State thread is currently idle (ie. no states)
+	SRESULT_SETSTAGE,		// Sets the current stage of the current state and reruns the state
+	SRESULT_DONE_FRAME,
+	// NOTE: this has to be the last result becuase the stage is added to
+	//		 the result.
+	SRESULT_SETDELAY = SRESULT_SETSTAGE + 20
+} stateResult_t;
+
+#define MAX_STATE_CALLS		50
+
+#define SRESULT_STAGE(x)	((stateResult_t)((int)SRESULT_SETSTAGE + (int)(x)))
+#define SRESULT_DELAY(x)	((stateResult_t)((int)SRESULT_SETDELAY + (int)(x)))
+
+struct stateParms_t
+{
+	int		blendFrames;
+	int		time;
+	int		stage;
+	int		substage;
+	float	param1;
+	float	param2;
+
+	float	subparam1;
+	float	subparam2;
+
+
+	void	Wait( float seconds );
+
+	void	Save( idSaveGame* saveFile ) const;
+	void	Restore( idRestoreGame* saveFile );
+};
+
+/*
+================
+CLASS_STATES_PROTOTYPE
+
+This macro must be included in the definition of any subclass of idClass that
+wishes to have its own custom states.  Its prototypes variables used in the process
+of managing states.
+================
+*/
+#define CLASS_STATES_PROTOTYPE(nameofclass)						\
+protected:														\
+	static	rvStateFunc<nameofclass>		stateCallbacks[]
+
+/*
+================
+CLASS_STATES_DECLARATION
+
+This macro must be included in the code to properly initialize variables
+used in state processing for a idClass dervied class
+================
+*/
+#define CLASS_STATES_DECLARATION(nameofclass)				\
+rvStateFunc<nameofclass> nameofclass::stateCallbacks[] = {
+
+/*
+================
+STATE
+
+This macro declares a single state.  It must be surrounded by the CLASS_STATES_DECLARATION
+and END_CLASS_STATES macros.
+================
+*/
+#define STATE(statename,function)			{ statename, (stateCallback_t)( &function ) },
+
+/*
+================
+END_CLASS_STATES
+
+Terminates a state block
+================
+*/
+#define END_CLASS_STATES					{ NULL, NULL } };
+
+struct stateCall_t
+{
+	idStr						state;
+	idLinkList<stateCall_t>		node;
+	int							flags;
+	int							delay;
+	stateParms_t				parms;
+
+	void						Save( idSaveGame* saveFile ) const;
+	void						Restore( idRestoreGame* saveFile, const idClass* owner );
+};
+
+class idClass;
+
+const int SFLAG_ONCLEAR			= BIT( 0 );			// Executes, even if the state queue is cleared
+const int SFLAG_ONCLEARONLY		= BIT( 1 );			// Executes only if the state queue is cleared
+
+class rvStateThread
+{
+public:
+
+	rvStateThread( void );
+	~rvStateThread( void );
+
+	void			SetName( const char* name );
+	void			SetOwner( idClass* owner );
+
+	bool			Interrupt( void );
+
+	stateResult_t	InterruptState( const char* state, int blendFrames = 0, int delay = 0, int flags = 0 );
+	stateResult_t	PostState( const char* state, int blendFrames = 0, int delay = 0, int flags = 0 );
+	stateResult_t	SetState( const char* state, int blendFrames = 0, int delay = 0, int flags = 0 );
+	stateCall_t*	GetState( void ) const;
+	bool			CurrentStateIs( const char* name ) const;
+
+	stateResult_t	Execute( void );
+
+	void			Clear( bool ignoreStateCalls = false );
+
+	bool			IsIdle( void ) const;
+	bool			IsExecuting( void ) const;
+
+	void			Save( idSaveGame* saveFile ) const;
+	void			Restore( idRestoreGame* saveFile, idClass* owner );
+
+protected:
+
+	struct flags
+	{
+		bool		stateCleared		: 1;		// State list was cleared
+		bool		stateInterrupted	: 1;		// State list was interrupted
+		bool		executing			: 1;		// Execute is currently processing states
+	} fl;
+
+	idStr						name;
+	idClass*					owner;
+	idLinkList<stateCall_t>		states;
+	idLinkList<stateCall_t>		interrupted;
+	stateCall_t*				insertAfter;
+	stateResult_t				lastResult;
+};
+
+ID_INLINE void rvStateThread::SetName( const char* _name )
+{
+	name = _name;
+}
+
+ID_INLINE stateCall_t* rvStateThread::GetState( void ) const
+{
+	return states.Next();
+}
+
+ID_INLINE bool rvStateThread::IsIdle( void ) const
+{
+	return !states.Next() && !interrupted.Next();
+}
+
+ID_INLINE bool rvStateThread::IsExecuting( void ) const
+{
+	return fl.executing;
+}
+
+#endif // __SYS_STATE_H__