MvtTMO.cpp

// MvtTMO.cpp : Top-Down Movement (Movement Extension)
// 
// Powerful top-down movement with 360 dirs, accel, decel,
// auto animations, embedded collision masks,
// and collision with slopes handling. PMO's brother!
//
// By Linky
// 
// ... Properties ...
//
// - Player									(By Fusion)
// - Help									(By Fusion)
//
// General:
// - Move at Start
// - Computer Controlled
// - Timer-based
// - Auto Animations
//
// Mask:
// - Enable Embedded Mask
// - Mask Anim Sequence
// - Rotate Mask With Object
//
// Movement Style:
// - Tank Movement
// - Auto Rotate
// - Rotate With Velocity
// - Circular Push Out
// - Rotation Control
// - Strafing Control
//
// Main:
// - Velocity X
// - Velocity Y
// - Additional Velocity X
// - Additional Velocity Y
// - Acceleration
// - Deceleration
// - Speed (Max Speed)
// - Backward Speed
// - Strafe Speed
// - Rotation Speed
// - Direction
//
// Advanced:
// - Movement Factor
// - Precision Quality
// - MoveNCollide Steps
// - Push Out Radius Step
// - Push Out Max Radius
// - Push Out Angle Step
// - Rotate Angle Epsilon
// - Collision Bounce Strength
//
// About:
// - Author
// - Version
// - Control Extension
// - Description
// 
// ... Actions ...
// 
// - Stop									(By Fusion, in On Collision)
// - Bounce									(By Fusion)
// 
// - Save Position							(By Fusion)
// - Load Position							(By Fusion)
// 
// TMOCtrl Communication:
// - Run Movement
// - Move Left
// - Move Right
// - Move Up
// - Move Down
// - Move Forward
// - Move Backward
// - Rotate Left
// - Rotate Right
// - Strafe Left
// - Strafe Right
// - Move To Direction
// - Set Move Direction
// - Set Magnitude
// - Apply Force
// - Set Velocity X
// - Set Velocity Y
// - Set Velocity X/Y
// - Set Velocity by Direction
// - Set Additional Velocity X
// - Set Additional Velocity Y
// - Set Additional Velocity X/Y
// - Set Additional Velocity by Direction
// - Set Final Velocity X
// - Set Final Velocity Y
// - Set Final Velocity X/Y
// - Set Final Velocity by Direction
// - Set Acceleration
// - Set Deceleration
// - Set Speed
// - Set Backward Speed
// - Set Strafe Speed
// - Set Rotation Speed
// - Set Movement Factor
// - Set Precision Quality
// - Set MoveNCollide Steps
// - Set Push Out Radius Step
// - Set Push Out Max Radius
// - Set Push Out Angle Step
// - Set Rotate Angle Epsilon
// - Set Collision Bounce Strength
//
// ... Expressions ...
//
// TMOCtrl Communication:
// - Velocity
// - Velocity X
// - Velocity Y
// - Additional Velocity
// - Additional Velocity X
// - Additional Velocity Y
// - Target Velocity
// - Target Velocity X
// - Target Velocity Y
// - Final Velocity
// - Final Velocity X
// - Final Velocity Y
// - Acceleration
// - Deceleration
// - Speed
// - Backward Speed
// - Strafe Speed
// - Rotation Speed
// - Direction
// - Real Direction
// - Magnitude
// - Movement Factor
// - Precision Quality
// - MoveNCollide Steps
// - Push Out Radius Step
// - Push Out Max Radius
// - Push Out Angle Step
// - Rotate Angle Epsilon
// - Collision Bounce Strength

#include "stdafx.h"
#include <strsafe.h>
#include <algorithm>
#include "Resource.h"
#include "MvtTMO.h"
//#include <string>

// Property IDs
// Note: Order can be changed, but keeping it original in case another extension relies on it for some reason, somehow.
enum
{
	/*
	PROPID_MVTTMO_SPEED = PROPID_MVTEXT_FIRST,
	PROPID_MVTTMO_NOFSEGMENTS,
	PROPID_MVTTMO_MOVEATSTART,
	PROPID_MVTTMO_INITIALDIR
	*/

	// General
	PROPID_MVTTMO_GROUPGENERAL = PROPID_MVTEXT_FIRST,
	PROPID_MVTTMO_MOVEATSTART,
	PROPID_MVTTMO_COMPUTERCONTROLLED,
	PROPID_MVTTMO_TIMERBASED,
	PROPID_MVTTMO_AUTOPLAYANIMS,
	// Mask
	PROPID_MVTTMO_GROUPMASK,
	PROPID_MVTTMO_ENABLEEMBEDDEDMASK,
	PROPID_MVTTMO_MASKANIMSEQ,
	PROPID_MVTTMO_ROTATEMASKWITHOBJECT,
	// Movement Style
	PROPID_MVTTMO_GROUPMOVEMENTSTYLE,
	PROPID_MVTTMO_TANKMVT,
	PROPID_MVTTMO_AUTOROT,
	PROPID_MVTTMO_ROTATEWITHVELOCITY,
	PROPID_MVTTMO_CIRCULARPUSHOUT,
	PROPID_MVTTMO_ROTATIONCONTROL,
	PROPID_MVTTMO_STRAFINGCONTROL,
	// Main
	PROPID_MVTTMO_GROUPMAIN,
	PROPID_MVTTMO_VELX,
	PROPID_MVTTMO_VELY,
	PROPID_MVTTMO_ADDVELX,
	PROPID_MVTTMO_ADDVELY,
	PROPID_MVTTMO_ACCEL,
	PROPID_MVTTMO_DECEL,
	PROPID_MVTTMO_SPD,
	PROPID_MVTTMO_DIR,
	PROPID_MVTTMO_ROTSPD,
	PROPID_MVTTMO_BACKWARDSPD,
	PROPID_MVTTMO_STRAFESPD,
	// Advanced
	PROPID_MVTTMO_GROUPADVANCED,
	PROPID_MVTTMO_MVTFACTOR,
	PROPID_MVTTMO_PRECISIONQUALITY,
	PROPID_MVTTMO_MOVENCOLLIDESTEPS,
	PROPID_MVTTMO_PUSHOUTRADIUSSTEP,
	PROPID_MVTTMO_PUSHOUTMAXRADIUS,
	PROPID_MVTTMO_PUSHOUTANGLESTEP,
	PROPID_MVTTMO_ROTATEANGLEEPSILON,
	PROPID_MVTTMO_COLLISIONBOUNCESTRENGTH,
	// About
	PROPID_MVTTMO_GROUPABOUT,
	PROPID_MVTTMO_AUTHOR,
	PROPID_MVTTMO_VERSION,
	PROPID_MVTTMO_CONTROLEXT,
	PROPID_MVTTMO_DESCRIPTION,

};

// Debugger IDs
enum
{
	DB_GROUPTOPDOWNX = DB_DECELERATION + 1,
	DB_VELX,
	DB_VELY,
	DB_ADDVELX,
	DB_ADDVELY,
	DB_TARGETVELX,
	DB_TARGETVELY,
	DB_FINALVELX,
	DB_FINALVELY,
	DB_ACCEL,
	DB_DECEL,
	DB_SPD,
	DB_ROTSPD,
	DB_DIR,
	DB_REALDIR,
	DB_MAGNITUDE,
	DB_MVTFACTOR,
	DB_PRECISIONQUALITY,
	DB_MOVENCOLLIDESTEPS
};

// Start of custom actions.
// Not mentioned anywhere btw except Clickteam Movement Controller's source-code :skull:
// Honestly, I don't even know if it really needs to be this high, maybe 0 would work just fine, but better safe than sorry!
// Like MVTACTION_SAVEPOSITION starts at 0x1010 (4112 in decimal), so we still have a big margin here...
// HUGE thanks to Yves (chad) for sending me Vector Movement & Clickteam Movement Controller source-codes :3
#define CUSTOM_ACTION_FIRST 3345

// Action IDs
enum
{
	// Actions
	SET_RUNMVT = CUSTOM_ACTION_FIRST,
	SET_MOVELEFT,
	SET_MOVERIGHT,
	SET_MOVEUP,
	SET_MOVEDOWN,
	SET_MOVEFORWARD,
	SET_MOVEBACKWARD,
	SET_ROTATELEFT,
	SET_ROTATERIGHT,
	SET_STRAFELEFT,
	SET_STRAFERIGHT,
	SET_MOVETODIR,
	SET_MOVEDIR,
	SET_MAGNITUDE,
	SET_APPLYFORCE,
	SET_VELX,
	SET_VELY,
	SET_VELXY,
	SET_VELDIR,
	SET_ADDVELX,
	SET_ADDVELY,
	SET_ADDVELXY,
	SET_ADDVELDIR,
	SET_FINALVELX,
	SET_FINALVELY,
	SET_FINALVELXY,
	SET_FINALVELDIR,
	SET_ACCEL,
	SET_DECEL,
	SET_SPD,
	SET_BACKWARDSPD,
	SET_ROTSPD,
	SET_STRAFESPD,
	SET_MVTFACTOR,
	SET_PRECISIONQUALITY,
	SET_MOVENCOLLIDESTEPS,
	SET_PUSHOUTRADIUSSTEP,
	SET_PUSHOUTMAXRADIUS,
	SET_PUSHOUTANGLESTEP,
	SET_ROTATEANGLEEPSILON,
	SET_COLLISIONBOUNCESTRENGTH,

	// Expressions
	GET_VEL,
	GET_VELX,
	GET_VELY,
	GET_ADDVEL,
	GET_ADDVELX,
	GET_ADDVELY,
	GET_TARGETVEL,
	GET_TARGETVELX,
	GET_TARGETVELY,
	GET_FINALVEL,
	GET_FINALVELX,
	GET_FINALVELY,
	GET_ACCEL,
	GET_DECEL,
	GET_SPD,
	GET_BACKWARDSPD,
	GET_ROTSPD,
	GET_STRAFESPD,
	GET_DIR,
	GET_REALDIR,
	GET_MAGNITUDE,
	GET_MVTFACTOR,
	GET_PRECISIONQUALITY,
	GET_MOVENCOLLIDESTEPS,
	GET_PUSHOUTRADIUSSTEP,
	GET_PUSHOUTMAXRADIUS,
	GET_PUSHOUTANGLESTEP,
	GET_ROTATEANGLEEPSILON,
	GET_COLLISIONBOUNCESTRENGTH
};

// Action Paramaters Payload
struct ActionParamPayload
{
	// Only 2 param are needed for now...
	DWORD dwValue1;
	DWORD dwValue2;
};

/*
MinMaxParam	MinMaxSpeed = { 0, 100 };
MinMaxParam	MinMaxNOfSegments = { 0, 50 };
DirCtrlCreateParam	initDirParam32 = { TRUE, 32, DCS_3D | DCS_SETALL_BTNS };
*/

DirCtrlCreateParam	dirParam32		=	{ TRUE, 32, DCS_3D | DCS_SETALL_BTNS	};
MinMaxParam			percentParam	=	{ 0,	100								};
MinMaxParam			aboveZeroParam	=	{ 0,	65535							};
MinMaxParam 		aboveOneParam	=	{ 1,	65535							};

LPCTSTR controlTypeComboList[] =
{
	0,
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_NONE),
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_LEFTRIGHT),
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_FIRE1),
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_FIRE2),
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_FIRE3),
	MAKEINTRESOURCE(IDS_MVTTMO_CONTROL_FIRE4),
	NULL
};

static DWORD ClampControlType(DWORD value)
{
	return (std::min)(value, (DWORD)TMO_CONTROL_FIRE4);
}

static BYTE GetFireButtonMask(DWORD controlType)
{
	switch (ClampControlType(controlType))
	{
	case TMO_CONTROL_FIRE1:
		return JOYSTICK_FIRE1;
	case TMO_CONTROL_FIRE2:
		return JOYSTICK_FIRE2;
	case TMO_CONTROL_FIRE3:
		return JOYSTICK_FIRE3;
	case TMO_CONTROL_FIRE4:
		return JOYSTICK_FIRE4;
	default:
		return 0;
	}
}

static bool IsTankSideControlActive(DWORD controlType, BYTE fireState)
{
	controlType = ClampControlType(controlType);

	if (controlType == TMO_CONTROL_NONE)
		return false;

	if (controlType == TMO_CONTROL_LEFTRIGHT)
		return true;

	return (fireState & GetFireButtonMask(controlType)) != 0;
}

// Property Data
PropData CMvtTMO::MvtProps[] =
{
	/*
	PropData_SliderEdit(PROPID_MVTTMO_SPEED, IDS_MVT_SPEED, IDS_MVT_SPEED_INFO, &MinMaxSpeed),
	PropData_SliderEdit(PROPID_MVTTMO_NOFSEGMENTS, IDS_MVT_NOFSEGMENTS, IDS_MVT_NOFSEGMENTS_INFO, &MinMaxNOfSegments),
	PropData_CheckBox(PROPID_MVTTMO_MOVEATSTART, IDS_MVT_MOVEATSTART, IDS_MVT_MOVEATSTART_INFO),
	PropData_DirCtrl(PROPID_MVTTMO_INITIALDIR, IDS_INITDIR, IDS_INITDIR_INFO, &initDirParam32),
	*/

	// Type,				ID,										Name (Title) String ID,				Info (Description) String ID,				Options

	// General
	PropData_Group			(PROPID_MVTTMO_GROUPGENERAL,			IDS_MVTTMO_GROUPGENERAL,			IDS_MVTTMO_GROUPGENERAL_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_MOVEATSTART,				IDS_MVTTMO_MOVEATSTART,				IDS_MVTTMO_MOVEATSTART_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_COMPUTERCONTROLLED,		IDS_MVTTMO_COMPUTERCONTROLLED,		IDS_MVTTMO_COMPUTERCONTROLLED_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_TIMERBASED,				IDS_MVTTMO_TIMERBASED,				IDS_MVTTMO_TIMERBASED_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_AUTOPLAYANIMS,			IDS_MVTTMO_AUTOPLAYANIMS,			IDS_MVTTMO_AUTOPLAYANIMS_INFO),
	// Mask
	PropData_Group			(PROPID_MVTTMO_GROUPMASK,				IDS_MVTTMO_GROUPMASK,				IDS_MVTTMO_GROUPMASK_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_ENABLEEMBEDDEDMASK,		IDS_MVTTMO_ENABLEEMBEDDEDMASK,		IDS_MVTTMO_ENABLEEMBEDDEDMASK_INFO),
	PropData_SpinEdit		(PROPID_MVTTMO_MASKANIMSEQ,				IDS_MVTTMO_MASKANIMSEQ,				IDS_MVTTMO_MASKANIMSEQ_INFO,				&aboveZeroParam),
	PropData_CheckBox		(PROPID_MVTTMO_ROTATEMASKWITHOBJECT,	IDS_MVTTMO_ROTATEMASKWITHOBJECT,	IDS_MVTTMO_ROTATEMASKWITHOBJECT_INFO),
	// Movement Style
	PropData_Group			(PROPID_MVTTMO_GROUPMOVEMENTSTYLE,		IDS_MVTTMO_GROUPMOVEMENTSTYLE,		IDS_MVTTMO_GROUPMOVEMENTSTYLE_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_TANKMVT,					IDS_MVTTMO_TANKMVT,					IDS_MVTTMO_TANKMVT_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_AUTOROT,					IDS_MVTTMO_AUTOROT,					IDS_MVTTMO_AUTOROT_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_ROTATEWITHVELOCITY,		IDS_MVTTMO_ROTATEWITHVELOCITY,		IDS_MVTTMO_ROTATEWITHVELOCITY_INFO),
	PropData_CheckBox		(PROPID_MVTTMO_CIRCULARPUSHOUT,			IDS_MVTTMO_CIRCULARPUSHOUT,			IDS_MVTTMO_CIRCULARPUSHOUT_INFO),
	PropData_ComboBox		(PROPID_MVTTMO_ROTATIONCONTROL,			IDS_MVTTMO_ROTATIONCONTROL,			IDS_MVTTMO_ROTATIONCONTROL_INFO,			controlTypeComboList),
	PropData_ComboBox		(PROPID_MVTTMO_STRAFINGCONTROL,			IDS_MVTTMO_STRAFINGCONTROL,			IDS_MVTTMO_STRAFINGCONTROL_INFO,			controlTypeComboList),
	// Main
	PropData_Group			(PROPID_MVTTMO_GROUPMAIN,				IDS_MVTTMO_GROUPMAIN,				IDS_MVTTMO_GROUPMAIN_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_VELX,					IDS_MVTTMO_VELX,					IDS_MVTTMO_VELX_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_VELY,					IDS_MVTTMO_VELY,					IDS_MVTTMO_VELY_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_ADDVELX,					IDS_MVTTMO_ADDVELX,					IDS_MVTTMO_ADDVELX_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_ADDVELY,					IDS_MVTTMO_ADDVELY,					IDS_MVTTMO_ADDVELY_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_ACCEL,					IDS_MVTTMO_ACCEL,					IDS_MVTTMO_ACCEL_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_DECEL,					IDS_MVTTMO_DECEL,					IDS_MVTTMO_DECEL_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_SPD,						IDS_MVTTMO_SPD,						IDS_MVTTMO_SPD_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_BACKWARDSPD,				IDS_MVTTMO_BACKWARDSPD,				IDS_MVTTMO_BACKWARDSPD_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_STRAFESPD,				IDS_MVTTMO_STRAFESPD,				IDS_MVTTMO_STRAFESPD_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_ROTSPD,					IDS_MVTTMO_ROTSPD,					IDS_MVTTMO_ROTSPD_INFO),
	PropData_DirCtrl		(PROPID_MVTTMO_DIR,						IDS_MVTTMO_DIR,						IDS_MVTTMO_DIR_INFO,						&dirParam32),
	// Advanced
	PropData_Group			(PROPID_MVTTMO_GROUPADVANCED,			IDS_MVTTMO_GROUPADVANCED,			IDS_MVTTMO_GROUPADVANCED_INFO),
	PropData_SpinEdit		(PROPID_MVTTMO_MVTFACTOR,				IDS_MVTTMO_MVTFACTOR,				IDS_MVTTMO_MVTFACTOR_INFO,					&aboveOneParam),
	PropData_SliderEdit		(PROPID_MVTTMO_PRECISIONQUALITY,		IDS_MVTTMO_PRECISIONQUALITY,		IDS_MVTTMO_PRECISIONQUALITY_INFO,			&percentParam),
	PropData_SpinEdit		(PROPID_MVTTMO_MOVENCOLLIDESTEPS,		IDS_MVTTMO_MOVENCOLLIDESTEPS,		IDS_MVTTMO_MOVENCOLLIDESTEPS_INFO,			&aboveOneParam),
	PropData_EditFloat		(PROPID_MVTTMO_PUSHOUTRADIUSSTEP,		IDS_MVTTMO_PUSHOUTRADIUSSTEP,		IDS_MVTTMO_PUSHOUTRADIUSSTEP_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_PUSHOUTMAXRADIUS,		IDS_MVTTMO_PUSHOUTMAXRADIUS,		IDS_MVTTMO_PUSHOUTMAXRADIUS_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_PUSHOUTANGLESTEP,		IDS_MVTTMO_PUSHOUTANGLESTEP,		IDS_MVTTMO_PUSHOUTANGLESTEP_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_ROTATEANGLEEPSILON,		IDS_MVTTMO_ROTATEANGLEEPSILON,		IDS_MVTTMO_ROTATEANGLEEPSILON_INFO),
	PropData_EditFloat		(PROPID_MVTTMO_COLLISIONBOUNCESTRENGTH, IDS_MVTTMO_COLLISIONBOUNCESTRENGTH, IDS_MVTTMO_COLLISIONBOUNCESTRENGTH_INFO),
	// About
	PropData_Group			(PROPID_MVTTMO_GROUPABOUT,				IDS_MVTTMO_GROUPABOUT,				IDS_MVTTMO_GROUPABOUT_INFO),
	PropData_StaticString	(PROPID_MVTTMO_AUTHOR,					IDS_MVTTMO_AUTHOR,					IDS_MVTTMO_AUTHOR_INFO),
	PropData_StaticString	(PROPID_MVTTMO_VERSION,					IDS_MVTTMO_VERSION,					IDS_MVTTMO_VERSION_INFO),
	PropData_StaticString	(PROPID_MVTTMO_CONTROLEXT,				IDS_MVTTMO_CONTROLEXT,				IDS_MVTTMO_CONTROLEXT_INFO),
	PropData_StaticString	(PROPID_MVTTMO_DESCRIPTION,				IDS_MVTTMO_DESCRIPTION,				IDS_MVTTMO_DESCRIPTION_INFO),

	PropData_End()
};

// Debug Tree
WORD CMvtTMO::DebugTree[] =
{
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_VELX,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_VELY,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_ADDVELX,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_ADDVELY,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_TARGETVELX,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_TARGETVELY,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_FINALVELX,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_FINALVELY,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_ACCEL,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_DECEL,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_SPD,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_ROTSPD,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_DIR,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_REALDIR,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_MAGNITUDE,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_MVTFACTOR,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_PRECISIONQUALITY,
	DB_GROUPTOPDOWNX		|DB_PARENT,
	DB_MOVENCOLLIDESTEPS,
	DB_END
};

/*
WORD CMvtTMO::DebugTree[] =
{
	DB_VELX | DB_EDITABLE,
	DB_VELY | DB_EDITABLE,
	DB_ADDVELX | DB_EDITABLE,
	DB_ADDVELY | DB_EDITABLE,
	DB_TARGETVELX,
	DB_TARGETVELY,
	DB_FINALVELX | DB_EDITABLE,
	DB_FINALVELY | DB_EDITABLE,
	DB_ACCEL | DB_EDITABLE,
	DB_DECEL | DB_EDITABLE,
	DB_SPD | DB_EDITABLE,
	DB_DIR | DB_EDITABLE,
	DB_REALDIR,
	DB_MAGNITUDE | DB_EDITABLE,
	DB_MVTFACTOR | DB_EDITABLE,
	DB_PRECISIONQUALITY | DB_EDITABLE,
	DB_MOVENCOLLIDESTEPS | DB_EDITABLE,
	DB_END
};
*/

////////////////////////////////////////////////
//
// Editor & Runtime class
//

// Constructor
CMvtTMO::CMvtTMO()
{
	/*
	m_dwSpeed = 50;
	m_dwFlags = MFLAG1_MOVEATSTART;
	m_dwNOfSegments = 10;
	m_dwInitialDir = 0xFFFFFFFF;
	*/

	m_dwPlayer							= MVCONT_PLAYER1;
//	m_dwFlags							= MFLAG1_MOVEATSTART | MFLAG3_TIMERBASED | MFLAG4_AUTOPLAYANIMS | MFLAG5_ENABLEEMBEDDEDMASK;
	m_dwFlags							= MFLAG1_MOVEATSTART | MFLAG3_TIMERBASED | MFLAG4_AUTOPLAYANIMS | MFLAG5_ENABLEEMBEDDEDMASK | MFLAG9_CIRCULARPUSHOUT;
	m_dwMaskAnimSeq						= 12;
	m_dwVelX							= FloatToDwordBits(0.0f);
	m_dwVelY							= FloatToDwordBits(0.0f);
	m_dwAddVelX							= FloatToDwordBits(0.0f);
	m_dwAddVelY							= FloatToDwordBits(0.0f);
	m_dwAccel							= FloatToDwordBits(1000.0f);
	m_dwDecel							= FloatToDwordBits(500.0f);
	m_dwSpd								= FloatToDwordBits(200.0f);
	m_dwBackwardSpd						= FloatToDwordBits(200.0f);
	m_dwStrafeSpd						= FloatToDwordBits(200.0f);
	m_dwRotSpd							= FloatToDwordBits(400.0f);
	m_dwDir								= 0;
	m_dwMvtFactor						= 100;
	m_dwPrecisionQuality				= 100;
	m_dwMoveNCollideSteps				= 1;
	m_dwPushOutRadiusStep				= FloatToDwordBits(1.0f);
	m_dwPushOutMaxRadius				= FloatToDwordBits(64.0f);
	m_dwPushOutAngleStep				= FloatToDwordBits(10.0f);
	m_dwRotateAngleEpsilon				= FloatToDwordBits(0.01f);
	m_dwCollisionBounceStrength			= FloatToDwordBits(1.0f);
	m_dwRotationControl					= TMO_CONTROL_LEFTRIGHT;
	m_dwStrafingControl					= TMO_CONTROL_FIRE1;
}

CMvtTMO::~CMvtTMO()
{}

// Initialize
void CMvtTMO::Initialize()
{}

// Clone
CMvt* CMvtTMO::Clone()
{
	CMvtTMO* pClone = new CMvtTMO;

	/*
	pClone->m_dwSpeed = m_dwSpeed;
	pClone->m_dwFlags = m_dwFlags;
	pClone->m_dwNOfSegments = m_dwNOfSegments;
	pClone->m_dwInitialDir = m_dwInitialDir;
	*/

	pClone->m_dwPlayer					= m_dwPlayer;
	pClone->m_dwFlags					= m_dwFlags;
	pClone->m_dwMaskAnimSeq				= m_dwMaskAnimSeq;
	pClone->m_dwVelX					= m_dwVelX;
	pClone->m_dwVelY					= m_dwVelY;
	pClone->m_dwAddVelX					= m_dwAddVelX;
	pClone->m_dwAddVelY					= m_dwAddVelY;
	pClone->m_dwAccel					= m_dwAccel;
	pClone->m_dwDecel					= m_dwDecel;
	pClone->m_dwSpd						= m_dwSpd;
	pClone->m_dwBackwardSpd				= m_dwBackwardSpd;
	pClone->m_dwStrafeSpd				= m_dwStrafeSpd;
	pClone->m_dwRotSpd					= m_dwRotSpd;
	pClone->m_dwDir						= m_dwDir;
	pClone->m_dwMvtFactor				= m_dwMvtFactor;
	pClone->m_dwPrecisionQuality		= m_dwPrecisionQuality;
	pClone->m_dwMoveNCollideSteps		= m_dwMoveNCollideSteps;
	pClone->m_dwPushOutRadiusStep		= m_dwPushOutRadiusStep;
	pClone->m_dwPushOutMaxRadius		= m_dwPushOutMaxRadius;
	pClone->m_dwPushOutAngleStep		= m_dwPushOutAngleStep;
	pClone->m_dwRotateAngleEpsilon		= m_dwRotateAngleEpsilon;
	pClone->m_dwCollisionBounceStrength = m_dwCollisionBounceStrength;
	pClone->m_dwRotationControl			= m_dwRotationControl;
	pClone->m_dwStrafingControl			= m_dwStrafingControl;

	return pClone;
}

// Operator ==
//
// Note: the class of pMvt is always the same as the current class
//
BOOL CMvtTMO::IsEqual(CMvt* pMvt)
{
	CMvtTMO* pMvtTMO = (CMvtTMO*)pMvt;

	/*
	if (m_dwSpeed != pMvtTMO->m_dwSpeed)
		return FALSE;
	if (m_dwFlags != pMvtTMO->m_dwFlags)
		return FALSE;
	if (m_dwNOfSegments != pMvtTMO->m_dwNOfSegments)
		return FALSE;
	if (m_dwInitialDir != pMvtTMO->m_dwInitialDir)
		return FALSE;
	*/

	if (m_dwPlayer						!= pMvtTMO->m_dwPlayer)
		return FALSE;
	if (m_dwFlags						!= pMvtTMO->m_dwFlags)
		return FALSE;
	if (m_dwMaskAnimSeq					!= pMvtTMO->m_dwMaskAnimSeq)
		return FALSE;
	if (m_dwVelX						!= pMvtTMO->m_dwVelX)
		return FALSE;
	if (m_dwVelY						!= pMvtTMO->m_dwVelY)
		return FALSE;
	if (m_dwAddVelX						!= pMvtTMO->m_dwAddVelX)
		return FALSE;
	if (m_dwAddVelY						!= pMvtTMO->m_dwAddVelY)
		return FALSE;
	if (m_dwAccel						!= pMvtTMO->m_dwAccel)
		return FALSE;
	if (m_dwDecel						!= pMvtTMO->m_dwDecel)
		return FALSE;
	if (m_dwSpd							!= pMvtTMO->m_dwSpd)
		return FALSE;
	if (m_dwBackwardSpd					!= pMvtTMO->m_dwBackwardSpd)
		return FALSE;
	if (m_dwStrafeSpd					!= pMvtTMO->m_dwStrafeSpd)
		return FALSE;
	if (m_dwRotSpd						!= pMvtTMO->m_dwRotSpd)
		return FALSE;
	if (m_dwDir							!= pMvtTMO->m_dwDir)
		return FALSE;
	if (m_dwMvtFactor					!= pMvtTMO->m_dwMvtFactor)
		return FALSE;
	if (m_dwPrecisionQuality			!= pMvtTMO->m_dwPrecisionQuality)
		return FALSE;
	if (m_dwMoveNCollideSteps			!= pMvtTMO->m_dwMoveNCollideSteps)
		return FALSE;
	if (m_dwPushOutRadiusStep			!= pMvtTMO->m_dwPushOutRadiusStep)
		return FALSE;
	if (m_dwPushOutMaxRadius			!= pMvtTMO->m_dwPushOutMaxRadius)
		return FALSE;
	if (m_dwPushOutAngleStep			!= pMvtTMO->m_dwPushOutAngleStep)
		return FALSE;
	if (m_dwRotateAngleEpsilon			!= pMvtTMO->m_dwRotateAngleEpsilon)
		return FALSE;
	if (m_dwCollisionBounceStrength		!= pMvtTMO->m_dwCollisionBounceStrength)
		return FALSE;
	if (m_dwRotationControl				!= pMvtTMO->m_dwRotationControl)
		return FALSE;
	if (m_dwStrafingControl				!= pMvtTMO->m_dwStrafingControl)
		return FALSE;

	return TRUE;
}

HINSTANCE CMvtTMO::GetModuleHandle()
{
	return hInst;
}

// Retrieves the player (MVCONT_COMPUTER = computer controlled movement, MVCONT_PLAYER1+ = player number)
// Note: the Player property is automatically added by MMF
int CMvtTMO::GetPlayer()
{
//	return MVCONT_COMPUTER;
	return (int)m_dwPlayer;
}

void CMvtTMO::SetPlayer(int nPlayer)
{
	m_dwPlayer = (DWORD)nPlayer;
}

// Returns TRUE if move at start
//
// Note: the Move At Start property is not automatically added by MMF. 
//       You must add it to your properties if you need it.

BOOL CMvtTMO::MoveAtStart()
{
	return (m_dwFlags & MFLAG1_MOVEATSTART) != 0;
}

// Returns the initial direction (32-bit mask)
//
// Note: the Initial Direction property is not automatically added by MMF. 
//       You must add it to your properties if you need it.
//
int CMvtTMO::DirAtStart()
{
	//	return m_dwInitialDir;
	return m_dwDir;
}

void CMvtTMO::ChangeScale(double dScaleX, double dScaleY)
{
	/*
	m_dwVelX	*= (float)dScaleX;
	m_dwVelY	*= (float)dScaleY;
	m_dwAddVelX *= (float)dScaleX;
	m_dwAddVelY *= (float)dScaleY;
	*/
}


// Properties
void CMvtTMO::GetProperties(CMvtPropMgr* pMvtPropMgr, BOOL bMasterItem)
{
	pMvtPropMgr->AddProps(MvtProps);
}

void CMvtTMO::RemoveProperties(CMvtPropMgr* pMvtPropMgr)
{
	pMvtPropMgr->RemoveProps(MvtProps);
}

CPropValue* CMvtTMO::GetPropertyValue(CMvtPropMgr* pMvtPropMgr, UINT nPropID)
{
	LPARAM lValue = 0; 

	switch (nPropID)
	{
		/*
		case PROPID_MVTTMO_SPEED:
			lValue = m_dwSpeed;
			break;

		case PROPID_MVTTMO_NOFSEGMENTS:
			lValue = m_dwNOfSegments;
			break;

		case PROPID_MVTTMO_INITIALDIR:
		{
			PropDirValue pv;
			memset(&pv, 0, sizeof(PropDirValue));
			pv.selDir32 = m_dwInitialDir;
			pv.numDirs = 32;
			return new CPropDataValue(sizeof(PropDirValue), (LPBYTE)&pv);
		}
		break;
		*/

	case PROPID_MVTTMO_MASKANIMSEQ:
		lValue = m_dwMaskAnimSeq;
		break;
	case PROPID_MVTTMO_VELX:
		return new CPropFloatValue(DwordBitsToFloat(m_dwVelX));
	case PROPID_MVTTMO_VELY:
		return new CPropFloatValue(DwordBitsToFloat(m_dwVelY));
	case PROPID_MVTTMO_ADDVELX:
		return new CPropFloatValue(DwordBitsToFloat(m_dwAddVelX));
	case PROPID_MVTTMO_ADDVELY:
		return new CPropFloatValue(DwordBitsToFloat(m_dwAddVelY));
	case PROPID_MVTTMO_ACCEL:
		return new CPropFloatValue(DwordBitsToFloat(m_dwAccel));
	case PROPID_MVTTMO_DECEL:
		return new CPropFloatValue(DwordBitsToFloat(m_dwDecel));
	case PROPID_MVTTMO_SPD:
		return new CPropFloatValue(DwordBitsToFloat(m_dwSpd));
	case PROPID_MVTTMO_BACKWARDSPD:
		return new CPropFloatValue(DwordBitsToFloat(m_dwBackwardSpd));
	case PROPID_MVTTMO_STRAFESPD:
		return new CPropFloatValue(DwordBitsToFloat(m_dwStrafeSpd));
	case PROPID_MVTTMO_ROTSPD:
		return new CPropFloatValue(DwordBitsToFloat(m_dwRotSpd));
	case PROPID_MVTTMO_DIR:
	{
		PropDirValue pDirValue;
		memset(&pDirValue, 0, sizeof(PropDirValue)); // Zeroing the structure to avoid unitialized data in the unused fields (selDir and reserved)
		pDirValue.selDir32	= m_dwDir;
		pDirValue.numDirs	= 32;
		return new CPropDataValue(sizeof(PropDirValue), (LPBYTE)&pDirValue);
	}
	case PROPID_MVTTMO_MVTFACTOR:
		lValue				= m_dwMvtFactor;
		break;
	case PROPID_MVTTMO_PRECISIONQUALITY:
		lValue				= m_dwPrecisionQuality;
		break;
	case PROPID_MVTTMO_MOVENCOLLIDESTEPS:
		lValue				= m_dwMoveNCollideSteps;
		break;
	case PROPID_MVTTMO_ROTATIONCONTROL:
		lValue				= m_dwRotationControl;
		break;
	case PROPID_MVTTMO_STRAFINGCONTROL:
		lValue				= m_dwStrafingControl;
		break;
	case PROPID_MVTTMO_PUSHOUTRADIUSSTEP:
		return new CPropFloatValue(DwordBitsToFloat(m_dwPushOutRadiusStep));
	case PROPID_MVTTMO_PUSHOUTMAXRADIUS:
		return new CPropFloatValue(DwordBitsToFloat(m_dwPushOutMaxRadius));
	case PROPID_MVTTMO_PUSHOUTANGLESTEP:
		return new CPropFloatValue(DwordBitsToFloat(m_dwPushOutAngleStep));
	case PROPID_MVTTMO_ROTATEANGLEEPSILON:
		return new CPropFloatValue(DwordBitsToFloat(m_dwRotateAngleEpsilon));
  case PROPID_MVTTMO_COLLISIONBOUNCESTRENGTH:
		return new CPropFloatValue(DwordBitsToFloat(m_dwCollisionBounceStrength));
	case PROPID_MVTTMO_AUTHOR:
	{
		TCHAR author[256];
		LoadString(hInst, IDS_MVTTMO_AUTHOR_CONTENT,		author,			256);
		return new CPropStringValue(author);
	}
	case PROPID_MVTTMO_VERSION:
	{
		TCHAR version[256];
		LoadString(hInst, IDS_MVTTMO_VERSION_CONTENT,		version,		256);
		return new CPropStringValue(version);
	}
	case PROPID_MVTTMO_CONTROLEXT:
	{
		TCHAR controlExt[256];
		LoadString(hInst, IDS_MVTTMO_CONTROLEXT_CONTENT,	controlExt,		256);
		return new CPropStringValue(controlExt);
	}
	case PROPID_MVTTMO_DESCRIPTION:
	{
		TCHAR description[256];
		LoadString(hInst, IDS_MVTTMO_DESCRIPTION_CONTENT,	description,	256);
		return new CPropStringValue(description);
	}
	break;
	}

	return new CPropDWordValue(lValue);
}

void CMvtTMO::SetPropertyValue(CMvtPropMgr* pMvtPropMgr, UINT nPropID, CPropValue* pValue)
{
	if (pValue == NULL)
		return;

	switch (nPropID)
	{
		/*
		case PROPID_MVTTMO_SPEED:
			m_dwSpeed = ((CPropDWordValue*)pValue)->m_dwValue;
			break;
		case PROPID_MVTTMO_NOFSEGMENTS:
			m_dwNOfSegments = ((CPropDWordValue*)pValue)->m_dwValue;
			break;
		case PROPID_MVTTMO_INITIALDIR:
		{
			PropDirValue* pv = (PropDirValue*)((CPropDataValue*)pValue)->m_pData;
			if (pv != NULL)
				m_dwInitialDir = pv->selDir32;
		}
		break;
		*/

	case PROPID_MVTTMO_MASKANIMSEQ:
		m_dwMaskAnimSeq				= ((CPropDWordValue*)pValue)->m_dwValue;
		break;

	case PROPID_MVTTMO_VELX:
		m_dwVelX					= FloatToDwordBits(((CPropFloatValue*)pValue)->m_fValue);
		break;
	case PROPID_MVTTMO_VELY:
		m_dwVelY					= FloatToDwordBits(((CPropFloatValue*)pValue)->m_fValue);
		break;
	case PROPID_MVTTMO_ADDVELX:
		m_dwAddVelX					= FloatToDwordBits(((CPropFloatValue*)pValue)->m_fValue);
		break;
	case PROPID_MVTTMO_ADDVELY:
		m_dwAddVelY					= FloatToDwordBits(((CPropFloatValue*)pValue)->m_fValue);
		break;
	case PROPID_MVTTMO_ACCEL:
		m_dwAccel					= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ACCEL, TRUE);
		break;
	case PROPID_MVTTMO_DECEL:
		m_dwDecel					= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_DECEL, TRUE);
		break;
	case PROPID_MVTTMO_SPD:
	{
//		m_dwSpd						= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		const float oldSpd			= DwordBitsToFloat(m_dwSpd);
		const float newSpd			= (std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue);
		const bool keepStrafeSynced	= DwordBitsToFloat(m_dwStrafeSpd) == oldSpd;
		
		m_dwSpd						= FloatToDwordBits(newSpd);
		if (keepStrafeSynced)
		{
			m_dwStrafeSpd			= FloatToDwordBits(newSpd);
			pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFESPD, TRUE);
		}
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_SPD, TRUE);
		break;
	}
	case PROPID_MVTTMO_BACKWARDSPD:
		m_dwBackwardSpd				= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_BACKWARDSPD, TRUE);
		break;
	case PROPID_MVTTMO_STRAFESPD:
		m_dwStrafeSpd = FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFESPD, TRUE);
		break;
	case PROPID_MVTTMO_ROTSPD:
		m_dwRotSpd					= FloatToDwordBits(((CPropFloatValue*)pValue)->m_fValue);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ROTSPD, TRUE);
		break;
	case PROPID_MVTTMO_DIR:
	{
		PropDirValue* pDirValue		= (PropDirValue*)((CPropDataValue*)pValue)->m_pData;
		if (pDirValue != NULL)
			m_dwDir = pDirValue->selDir32;
		break;
	}
	case PROPID_MVTTMO_MVTFACTOR:
	{
		const DWORD newMvtFactor	= ((CPropDWordValue*)pValue)->m_dwValue;
		const DWORD oldMvtFactor	= (std::max)(1u, (unsigned int)m_dwMvtFactor);

		const float linearScale		= newMvtFactor / (float)oldMvtFactor;
		const float accelScale		= linearScale * linearScale;

		m_dwMvtFactor				= (std::max)(1u, (unsigned int)newMvtFactor);

		m_dwVelX					= FloatToDwordBits(DwordBitsToFloat(m_dwVelX)			* linearScale);
		m_dwVelY					= FloatToDwordBits(DwordBitsToFloat(m_dwVelY)			* linearScale);
		m_dwAddVelX					= FloatToDwordBits(DwordBitsToFloat(m_dwAddVelX)		* linearScale);
		m_dwAddVelY					= FloatToDwordBits(DwordBitsToFloat(m_dwAddVelY)		* linearScale);
		m_dwAccel					= FloatToDwordBits(DwordBitsToFloat(m_dwAccel)			* accelScale);
		m_dwDecel					= FloatToDwordBits(DwordBitsToFloat(m_dwDecel)			* accelScale);
		m_dwSpd						= FloatToDwordBits(DwordBitsToFloat(m_dwSpd)			* linearScale);
		m_dwBackwardSpd				= FloatToDwordBits(DwordBitsToFloat(m_dwBackwardSpd)	* linearScale);
		m_dwStrafeSpd				= FloatToDwordBits(DwordBitsToFloat(m_dwStrafeSpd)		* linearScale);
		m_dwRotSpd					= FloatToDwordBits(DwordBitsToFloat(m_dwRotSpd)			* linearScale);

		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_VELX,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_VELY,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ADDVELX,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ADDVELY,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ACCEL,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_DECEL,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_SPD,			TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_BACKWARDSPD, TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFESPD,	TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ROTSPD,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_MVTFACTOR,	TRUE);
		break;
	}
	case PROPID_MVTTMO_PRECISIONQUALITY:
		m_dwPrecisionQuality		= ((CPropDWordValue*)pValue)->m_dwValue;
		break;
	case PROPID_MVTTMO_MOVENCOLLIDESTEPS:
		m_dwMoveNCollideSteps		= ((CPropDWordValue*)pValue)->m_dwValue;
		break;
	case PROPID_MVTTMO_ROTATIONCONTROL:
		m_dwRotationControl			= ClampControlType(((CPropDWordValue*)pValue)->m_dwValue);
		break;
	case PROPID_MVTTMO_STRAFINGCONTROL:
		m_dwStrafingControl			= ClampControlType(((CPropDWordValue*)pValue)->m_dwValue);
		break;
	case PROPID_MVTTMO_PUSHOUTRADIUSSTEP:
		m_dwPushOutRadiusStep		= FloatToDwordBits((std::max)(0.001f, ((CPropFloatValue*)pValue)->m_fValue));
		break;
	case PROPID_MVTTMO_PUSHOUTMAXRADIUS:
		m_dwPushOutMaxRadius		= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		break;
	case PROPID_MVTTMO_PUSHOUTANGLESTEP:
		m_dwPushOutAngleStep		= FloatToDwordBits((std::max)(0.001f, ((CPropFloatValue*)pValue)->m_fValue));
		break;
	case PROPID_MVTTMO_ROTATEANGLEEPSILON:
		m_dwRotateAngleEpsilon		= FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		break;
   case PROPID_MVTTMO_COLLISIONBOUNCESTRENGTH:
		m_dwCollisionBounceStrength = FloatToDwordBits((std::max)(0.0f, ((CPropFloatValue*)pValue)->m_fValue));
		break;
	}
}

int CMvtTMO::GetPropertyCheck(CMvtPropMgr* pMvtPropMgr, UINT nPropID)
{
	switch (nPropID)
	{
		/*
		case PROPID_MVTTMO_MOVEATSTART:
			return ((m_dwFlags & MFLAG1_MOVEATSTART) != 0);
		*/

	case PROPID_MVTTMO_MOVEATSTART:
		return (m_dwFlags & MFLAG1_MOVEATSTART)				!= 0;
	case PROPID_MVTTMO_COMPUTERCONTROLLED:
		return (m_dwFlags & MFLAG2_COMPUTERCONTROLLED)		!= 0;
	case PROPID_MVTTMO_TIMERBASED:
		return (m_dwFlags & MFLAG3_TIMERBASED)				!= 0;
	case PROPID_MVTTMO_AUTOPLAYANIMS:
		return (m_dwFlags & MFLAG4_AUTOPLAYANIMS)			!= 0;
	case PROPID_MVTTMO_ENABLEEMBEDDEDMASK:
		return (m_dwFlags & MFLAG5_ENABLEEMBEDDEDMASK)		!= 0;
	case PROPID_MVTTMO_TANKMVT: 
		return (m_dwFlags & MFLAG6_TANKMVT)					!= 0;
	case PROPID_MVTTMO_AUTOROT:
		return (m_dwFlags & MFLAG7_AUTOROT)					!= 0;
	case PROPID_MVTTMO_ROTATEWITHVELOCITY:
		return (m_dwFlags & MFLAG8_ROTATEWITHVELOCITY)		!= 0;
	case PROPID_MVTTMO_CIRCULARPUSHOUT:
		return (m_dwFlags & MFLAG9_CIRCULARPUSHOUT)			!= 0;
	case PROPID_MVTTMO_ROTATEMASKWITHOBJECT:
		return (m_dwFlags & MFLAG10_ROTATEMASKWITHOBJECT)	!= 0;
	}
	return FALSE;
}

void CMvtTMO::SetPropertyCheck(CMvtPropMgr* pMvtPropMgr, UINT nPropID, int nCheck)
{
	switch (nPropID)
	{
		/*
		case PROPID_MVTTMO_MOVEATSTART:
			m_dwFlags &= ~MFLAG1_MOVEATSTART;
			if (nCheck)
				m_dwFlags |= MFLAG1_MOVEATSTART;
			break;
		*/

	case PROPID_MVTTMO_MOVEATSTART:
		m_dwFlags &= ~MFLAG1_MOVEATSTART;
		if (nCheck)
			m_dwFlags |= MFLAG1_MOVEATSTART;
		break;
	case PROPID_MVTTMO_COMPUTERCONTROLLED:
		m_dwFlags &= ~MFLAG2_COMPUTERCONTROLLED;
		if (nCheck)
			m_dwFlags |= MFLAG2_COMPUTERCONTROLLED;
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ROTATIONCONTROL,			TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFINGCONTROL,			TRUE);
		break;
	case PROPID_MVTTMO_TIMERBASED:
		m_dwFlags &= ~MFLAG3_TIMERBASED;
		if (nCheck)
			m_dwFlags |= MFLAG3_TIMERBASED;
		break;
	case PROPID_MVTTMO_AUTOPLAYANIMS:
		m_dwFlags &= ~MFLAG4_AUTOPLAYANIMS;
		if (nCheck)
			m_dwFlags |= MFLAG4_AUTOPLAYANIMS;
		break;
	case PROPID_MVTTMO_ENABLEEMBEDDEDMASK:
		m_dwFlags &= ~MFLAG5_ENABLEEMBEDDEDMASK;
		if (nCheck)
			m_dwFlags |= MFLAG5_ENABLEEMBEDDEDMASK;
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_MASKANIMSEQ,				TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ROTATEMASKWITHOBJECT,	TRUE);
		break;
	case PROPID_MVTTMO_ROTATEMASKWITHOBJECT:
		m_dwFlags &= ~MFLAG10_ROTATEMASKWITHOBJECT;
		if (nCheck)
			m_dwFlags |= MFLAG10_ROTATEMASKWITHOBJECT;
		break;
	case PROPID_MVTTMO_TANKMVT:
		m_dwFlags &= ~MFLAG6_TANKMVT;
		if (nCheck)
			m_dwFlags |= MFLAG6_TANKMVT;
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_BACKWARDSPD,				TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFESPD,				TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_ROTATIONCONTROL,			TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_STRAFINGCONTROL,			TRUE);
		break;
	case PROPID_MVTTMO_AUTOROT:
		m_dwFlags &= ~MFLAG7_AUTOROT;
		if (nCheck)
			m_dwFlags |= MFLAG7_AUTOROT;
		break;
	case PROPID_MVTTMO_ROTATEWITHVELOCITY:
		m_dwFlags &= ~MFLAG8_ROTATEWITHVELOCITY;
		if (nCheck)
			m_dwFlags |= MFLAG8_ROTATEWITHVELOCITY;
		break;
	case PROPID_MVTTMO_CIRCULARPUSHOUT:
		m_dwFlags &= ~MFLAG9_CIRCULARPUSHOUT;
		if (nCheck)
			m_dwFlags |= MFLAG9_CIRCULARPUSHOUT;
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_PUSHOUTRADIUSSTEP,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_PUSHOUTMAXRADIUS,		TRUE);
		pMvtPropMgr->RefreshProp(PROPID_MVTTMO_PUSHOUTANGLESTEP,		TRUE);
		break;
	}
}

BOOL CMvtTMO::IsPropertyEnabled(CMvtPropMgr* pMvtPropMgr, UINT nPropID)
{
	switch (nPropID)
	{
	// The Mask Anim Seq property is only enabled if the Enable Embedded Mask property is checked
	case PROPID_MVTTMO_MASKANIMSEQ:
	case PROPID_MVTTMO_ROTATEMASKWITHOBJECT:
		return (m_dwFlags & MFLAG5_ENABLEEMBEDDEDMASK)	!= 0;

	case PROPID_MVTTMO_BACKWARDSPD:
	case PROPID_MVTTMO_STRAFESPD:
		return (m_dwFlags & MFLAG6_TANKMVT)				!= 0;

	case PROPID_MVTTMO_ROTATIONCONTROL:
	case PROPID_MVTTMO_STRAFINGCONTROL:
		return (m_dwFlags & MFLAG6_TANKMVT)				!= 0
			&& (m_dwFlags & MFLAG2_COMPUTERCONTROLLED)	== 0;

	case PROPID_MVTTMO_PUSHOUTRADIUSSTEP:
	case PROPID_MVTTMO_PUSHOUTMAXRADIUS:
	case PROPID_MVTTMO_PUSHOUTANGLESTEP:
		return (m_dwFlags & MFLAG9_CIRCULARPUSHOUT)		!= 0;

	case PROPID_MVTTMO_ROTATEANGLEEPSILON:
		return (m_dwFlags & MFLAG7_AUTOROT)				!= 0;
	default:
		return TRUE;
	}

//	return TRUE;
}

BOOL CMvtTMO::EditProperty(CMvtPropMgr* pMvtPropMgr, UINT nPropID)
{
	return FALSE;
}

LPARAM CMvtTMO::GetPropertyCreateParam(CMvtPropMgr* pMvtPropMgr, UINT nPropID)
{
	return NULL;
}

void CMvtTMO::ReleasePropertyCreateParam(CMvtPropMgr* pMvtPropMgr, UINT nPropID, LPARAM lCreateParam)
{}

BOOL CMvtTMO::Load(LPBYTE pBuf, DWORD dwSize, DWORD dwFlags)
{
	/*
	BYTE b;
	LPBYTE pb = pBuf;

	// Check size
	if (dwSize != sizeof(BYTE) + sizeof(DWORD) * EDITDATA_ENTRIES)
		return FALSE;

	// Version number
	b = *pb++;
	if (b > 0)
		return FALSE;

	// Flags
	m_dwFlags = *((LPDWORD)pb);
	pb += sizeof(DWORD);

	// Speed
	m_dwSpeed = *((LPDWORD)pb);
	pb += sizeof(DWORD);

	// Segment Size
	m_dwNOfSegments = *((LPDWORD)pb);
	pb += sizeof(DWORD);

	// Initial direction
	m_dwInitialDir = *((LPDWORD)pb);
	pb += sizeof(DWORD);
	*/

	if (pBuf == nullptr)
		return FALSE;											// Prevents null dereference
	if (dwSize < sizeof(BYTE))
		return FALSE;											// Prevents reading version when there isn't even 1 byte available
	BOOL	bRuntime		= (dwFlags & MVT_LF_RUNTIME) != 0;	// Runtime or not. Not used for now...
	LPBYTE	pb				= pBuf;								// Pointer to navigate through the buffer
	BYTE	version			= *pb++;							// Read version number and move pointer forward
//	MessageBox(NULL, std::to_wstring(version).c_str(), L"Version", MB_OK);
	if (version > EDITDATA_VERSION)
		return FALSE;											// Future version, not supported
	DWORD	expectedSize	= 0;								// Value to hold the expected size of the data based on version

	// Determine expected size based on version
	switch (version)
	{
	// Version 0: Initial version
	case 0:
		expectedSize = sizeof(BYTE) + sizeof(DWORD) * EDITDATA_ENTRIES_V0;
		break;

	// Version 1: Float-backed values are stored as float bits in DWORDs
	case 1:
		expectedSize = sizeof(BYTE) + sizeof(DWORD) * EDITDATA_ENTRIES_V1;
		break;

	// Version 2: Added RotSpd property along with other related Tank properties
	case 2:
		expectedSize = sizeof(BYTE) + sizeof(DWORD) * EDITDATA_ENTRIES_V2;
		break;

	default:
		return FALSE;
	}

	if (dwSize != expectedSize)
		return FALSE;	// Size mismatch, invalid data

	// Read initial fields (common for all versions)

	// Player
	m_dwPlayer						= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Flags
	m_dwFlags						= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// MaskAnimSeq
	m_dwMaskAnimSeq					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// VelX
	if (version == 0)
		m_dwVelX					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwVelX					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// VelY
	if (version == 0)
		m_dwVelY					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwVelY					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// AddVelX
	if (version == 0)
		m_dwAddVelX					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwAddVelX					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// AddVelY
	if (version == 0)
		m_dwAddVelY					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwAddVelY					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Accel
	if (version == 0)
		m_dwAccel					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwAccel					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Decel
	if (version == 0)
		m_dwDecel					= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwDecel					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Spd
	if (version == 0)
		m_dwSpd						= FloatToDwordBits((float)(*((LPDWORD)pb)));
	else
		m_dwSpd						= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Dir
	m_dwDir							= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// MvtFactor
	m_dwMvtFactor					= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// PrecisionQuality
	m_dwPrecisionQuality			= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// MoveNCollideSteps
	m_dwMoveNCollideSteps			= *((LPDWORD)pb);
	pb								+= sizeof(DWORD);

	// Defaults for new fields
	// Note: Can rely on initialization in the constructor for fields added after the last version,
	// since they will be set to their default values when loading older versions that don't have them.
	// However, it's good practice to explicitly set defaults here as well for clarity and in case the constructor defaults change in the future.
//	m_dwNewProperty					= 123;

	m_dwBackwardSpd					= FloatToDwordBits(200.0f);
	m_dwStrafeSpd					= m_dwSpd; // Preserving the old full-speed strafing behavior
	m_dwRotSpd						= FloatToDwordBits(400.0f);
	m_dwPushOutRadiusStep			= FloatToDwordBits(1.0f);
	m_dwPushOutMaxRadius			= FloatToDwordBits(64.0f);
	m_dwPushOutAngleStep			= FloatToDwordBits(10.0f);
	m_dwRotateAngleEpsilon			= FloatToDwordBits(0.01f);
	m_dwCollisionBounceStrength		= FloatToDwordBits(1.0f);
	m_dwRotationControl				= TMO_CONTROL_LEFTRIGHT;
	m_dwStrafingControl				= TMO_CONTROL_FIRE1;
//	m_dwFlags						|= MFLAG9_CIRCULARPUSHOUT; // Thank god this was catched...
	// Only force-set the flag for old versions that didn't have it
	if (version < 2)
		m_dwFlags					|= MFLAG9_CIRCULARPUSHOUT;

	// Read new fields based on version
//	if (version >= 1)
//	{
		// NewProperty
//		m_dwNewProperty				= *((LPDWORD)pb);
//		pb							+= sizeof(DWORD);
//	}

	if (version >= 2)
	{
		m_dwBackwardSpd				= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwStrafeSpd				= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwRotSpd					= *((LPDWORD)pb);
		pb 							+= sizeof(DWORD);

		m_dwPushOutRadiusStep		= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwPushOutMaxRadius		= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwPushOutAngleStep		= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwRotateAngleEpsilon		= *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwCollisionBounceStrength = *((LPDWORD)pb);
		pb							+= sizeof(DWORD);

		m_dwRotationControl			= ClampControlType(*((LPDWORD)pb));
		pb							+= sizeof(DWORD);

		m_dwStrafingControl			= ClampControlType(*((LPDWORD)pb));
		pb							+= sizeof(DWORD);
	}

	return TRUE;
}

BOOL CMvtTMO::Save(LPBYTE pBuf, LPDWORD pDWSize, DWORD dwFlags)
{
	BOOL bRuntime = (dwFlags & MVT_LF_RUNTIME) != 0;
	LPBYTE pb = pBuf;
	BYTE b;

//	MessageBox(NULL, L"Save called", L"Save", MB_OK);

	if (pBuf != NULL)
	{
		/*
		// Version number
		b = 0;
		*pb++ = b;

		// Flags
		*((LPDWORD)pb) = m_dwFlags;
		pb += sizeof(DWORD);

		// Speed
		*((LPDWORD)pb) = m_dwSpeed;
		pb += sizeof(DWORD);

		// Segment Size
		*((LPDWORD)pb) = m_dwNOfSegments;
		pb += sizeof(DWORD);

		// Initial Direction
		*((LPDWORD)pb) = m_dwInitialDir;
		pb += sizeof(DWORD);
		*/

		// Version number
		b				= EDITDATA_VERSION;
		*pb++			= b;

		// Player
		*((LPDWORD)pb)	= m_dwPlayer;
		pb				+= sizeof(DWORD);

		// Flags
		*((LPDWORD)pb)	= m_dwFlags;
		pb				+= sizeof(DWORD);

		// MaskAnimSeq
		*((LPDWORD)pb)	= m_dwMaskAnimSeq;
		pb				+= sizeof(DWORD);

		// VelX
		*((LPDWORD)pb)	= m_dwVelX;
		pb				+= sizeof(DWORD);

		// VelY
		*((LPDWORD)pb)	= m_dwVelY;
		pb				+= sizeof(DWORD);

		// AddVelX
		*((LPDWORD)pb)	= m_dwAddVelX;
		pb				+= sizeof(DWORD);

		// AddVelY
		*((LPDWORD)pb)	= m_dwAddVelY;
		pb				+= sizeof(DWORD);

		// Accel
		*((LPDWORD)pb)	= m_dwAccel;
		pb				+= sizeof(DWORD);

		// Decel
		*((LPDWORD)pb)	= m_dwDecel;
		pb				+= sizeof(DWORD);

		// Spd
		*((LPDWORD)pb)	= m_dwSpd;
		pb				+= sizeof(DWORD);

		// Dir
		*((LPDWORD)pb)	= m_dwDir;
		pb				+= sizeof(DWORD);

		// MvtFactor
		*((LPDWORD)pb)	= m_dwMvtFactor;
		pb				+= sizeof(DWORD);

		// PrecisionQuality
		*((LPDWORD)pb)	= m_dwPrecisionQuality;
		pb				+= sizeof(DWORD);

		// MoveNCollideSteps
		*((LPDWORD)pb)	= m_dwMoveNCollideSteps;
		pb				+= sizeof(DWORD);

		// BackwardSpd
		*((LPDWORD)pb)	= m_dwBackwardSpd;
		pb				+= sizeof(DWORD);

		// StrafeSpd
		*((LPDWORD)pb)	= m_dwStrafeSpd;
		pb				+= sizeof(DWORD);
		
		// RotSpd
		*((LPDWORD)pb)	= m_dwRotSpd;
		pb				+= sizeof(DWORD);
		
		// PushOutRadiusStep
		*((LPDWORD)pb)	= m_dwPushOutRadiusStep;
		pb				+= sizeof(DWORD);
		
		// PushOutMaxRadius
		*((LPDWORD)pb)	= m_dwPushOutMaxRadius;
		pb				+= sizeof(DWORD);
		
		// PushOutAngleStep
		*((LPDWORD)pb)	= m_dwPushOutAngleStep;
		pb				+= sizeof(DWORD);
		
		// RotateAngleEpsilon
		*((LPDWORD)pb)	= m_dwRotateAngleEpsilon;
		pb				+= sizeof(DWORD);

		// CollisionBounceStrength
		*((LPDWORD)pb)	= m_dwCollisionBounceStrength;
		pb				+= sizeof(DWORD);

		// RotationControl
		*((LPDWORD)pb)	= ClampControlType(m_dwRotationControl);
		pb				+= sizeof(DWORD);

		// StrafingControl
		*((LPDWORD)pb)	= ClampControlType(m_dwStrafingControl);
		pb				+= sizeof(DWORD);

		// New fields here...
	}
	*pDWSize = sizeof(BYTE) + sizeof(DWORD) * EDITDATA_ENTRIES;

	return TRUE;
}

BOOL CMvtTMO::IsActionEnabled(short action)
{
	switch (action)
	{
		/*
		case ACT_EXTSTOP:
		case ACT_EXTSTART:
		case ACT_EXTBOUNCE:
		case ACT_EXTREVERSE:
			return TRUE;

		case ACT_EXTSETGRAVITY:
		case ACT_EXTSPEED:
		case ACT_EXTWRAP:
		case ACT_EXTMAXSPEED:
		case ACT_EXTSETACCELERATION:
		case ACT_EXTSETDECELERATION:
		case ACT_EXTSETROTATINGSPEED:
		case ACT_EXTSETDIRECTIONS:
			break;
		*/

	// Enable
	case ACT_EXTSTOP:
	case ACT_EXTBOUNCE:
		return TRUE;

	// Disable
	case ACT_EXTSTART:
	case ACT_EXTREVERSE:
	case ACT_EXTSETGRAVITY:
	case ACT_EXTSPEED:
	case ACT_EXTWRAP:
	case ACT_EXTMAXSPEED:
	case ACT_EXTSETACCELERATION:
	case ACT_EXTSETDECELERATION:
	case ACT_EXTSETROTATINGSPEED:
	case ACT_EXTSETDIRECTIONS:
		break;
	}
	return FALSE;
}

CRunMvt* CMvtTMO::CreateRunMvt()
{
	CRunMvtTMO* prm = new CRunMvtTMO;
	return prm;
}

////////////////////////////////////////////////
//
// Runtime only class
//

/*
CRunMvtTMO::CRunMvtTMO()
{}

CRunMvtTMO::~CRunMvtTMO()
{
	if (this->topDownX != nullptr)
	{
		delete this->topDownX;
		this->topDownX = nullptr;
	}
	this->m_pHo		= nullptr;
}
*/

CRunMvtTMO::CRunMvtTMO()	= default;

CRunMvtTMO::~CRunMvtTMO()	= default;

// Initialize the movement
// -----------------------
void CRunMvtTMO::Initialize(CMvt* pMvt, LPHO pHo)
{
	// Store pointer to edit data
	m_pMvt		= (CMvtTMO*)pMvt;

	// Initialisations
	LPRO pRo	= (LPRO)pHo;
	this->m_pHo = pHo;

	/*
	m_segmentCount = m_pMvt->m_dwNOfSegments;
	pRo->roc.rcSpeed = m_pMvt->m_dwSpeed;
	if ((m_pMvt->m_dwFlags & MFLAG1_MOVEATSTART) == 0)
		pRo->roc.rcSpeed = 0;
	

	// Finds the initial direction
	pRo->roc.rcDir = callDirAtStart(pHo, m_pMvt->m_dwInitialDir);
	m_dir = 8;
	*/

	// Movement props to pass to the TopDownX movement
	Linky::TopDownX::PropData mvtPropData;

	mvtPropData.SetPosX						(pHo->hoX);
	mvtPropData.SetPosY						(pHo->hoY);
	mvtPropData.SetVelX						(DwordBitsToFloat(m_pMvt->m_dwVelX));
	mvtPropData.SetVelY						(DwordBitsToFloat(m_pMvt->m_dwVelY));
	mvtPropData.SetAddVelX					(DwordBitsToFloat(m_pMvt->m_dwAddVelX));
	mvtPropData.SetAddVelY					(DwordBitsToFloat(m_pMvt->m_dwAddVelY));
	mvtPropData.SetAccel					(DwordBitsToFloat(m_pMvt->m_dwAccel));
	mvtPropData.SetDecel					(DwordBitsToFloat(m_pMvt->m_dwDecel));
	mvtPropData.SetSpd						(DwordBitsToFloat(m_pMvt->m_dwSpd));
	mvtPropData.SetBackwardSpd				(DwordBitsToFloat(m_pMvt->m_dwBackwardSpd));
	mvtPropData.SetStrafeSpd				(DwordBitsToFloat(m_pMvt->m_dwStrafeSpd));
	mvtPropData.SetRotationSpeed			(DwordBitsToFloat(m_pMvt->m_dwRotSpd));
	mvtPropData.SetMoveDir					((int)(callDirAtStart(pHo, m_pMvt->m_dwDir) * 11.25f) % 360); // Converting from 32 directions to degrees (0-360)
	mvtPropData.SetMvtFactor				(m_pMvt->m_dwMvtFactor);
	mvtPropData.SetPrecisionQuality			((unsigned short)m_pMvt->m_dwPrecisionQuality);
	mvtPropData.SetMoveNCollideSteps		(m_pMvt->m_dwMoveNCollideSteps);
	mvtPropData.SetCircularPushOut			((m_pMvt->m_dwFlags & MFLAG9_CIRCULARPUSHOUT)		!= 0);
	mvtPropData.SetPushOutRadiusStep		(DwordBitsToFloat(m_pMvt->m_dwPushOutRadiusStep));
	mvtPropData.SetPushOutMaxRadius			(DwordBitsToFloat(m_pMvt->m_dwPushOutMaxRadius));
	mvtPropData.SetPushOutAngleStep			(DwordBitsToFloat(m_pMvt->m_dwPushOutAngleStep));
	mvtPropData.SetRotateAngleEpsilon		(DwordBitsToFloat(m_pMvt->m_dwRotateAngleEpsilon));
	mvtPropData.SetCollisionBounceStrength	(DwordBitsToFloat(m_pMvt->m_dwCollisionBounceStrength));
	mvtPropData.SetMaskAnimSeq				(m_pMvt->m_dwMaskAnimSeq);
	mvtPropData.SetEnableEmbeddedMask		((m_pMvt->m_dwFlags & MFLAG5_ENABLEEMBEDDEDMASK)	!= 0);
	mvtPropData.SetRotateMaskWithObject		((m_pMvt->m_dwFlags & MFLAG10_ROTATEMASKWITHOBJECT) != 0);
	mvtPropData.SetAutoPlayAnims			((m_pMvt->m_dwFlags & MFLAG4_AUTOPLAYANIMS)			!= 0);
	mvtPropData.SetAutoRotate 				((m_pMvt->m_dwFlags & MFLAG7_AUTOROT)				!= 0);
	mvtPropData.SetRotateWithVelocity		((m_pMvt->m_dwFlags & MFLAG8_ROTATEWITHVELOCITY)	!= 0);
	mvtPropData.SetTimerBased				((m_pMvt->m_dwFlags & MFLAG3_TIMERBASED)			!= 0);

	/*
	// Just in case Fusion can initialize the movement more than once for the same object without destroying it?
	if (this->topDownX != nullptr)
	{
		delete this->topDownX;
		this->topDownX = nullptr;
	}
	this->topDownX = new Linky::TopDownX(pHo, mvtPropData);					// Creating the movement with the properties
	*/

	this->topDownX = std::make_unique<Linky::TopDownX>(pHo, mvtPropData);	// Creating the movement with the properties (safer using smart pointer)

	// ... Control ...

	this->topDownX->SetInputCallback([this](Linky::TopDownX& mvt)
		{
			/*
			switch (this->joystickState)
			{
			// Left			(0)
			case JOYSTICK_LEFT:
				mvt.MoveLeft();
				break;
			// Right		(180)
			case JOYSTICK_RIGHT:
				mvt.MoveRight();
				break;
			// Up			(90)
			case JOYSTICK_UP:
				mvt.MoveUp();
				break;
			// Down			(270)
			case JOYSTICK_DOWN:
				mvt.MoveDown();
				break;
			// Left Up		(135)
			case JOYSTICK_LEFT	| JOYSTICK_UP:
				mvt.MoveLeft();
				mvt.MoveUp();
				break;
			// Right Up		(45)
			case JOYSTICK_RIGHT | JOYSTICK_UP:
				mvt.MoveRight();
				mvt.MoveUp();
				break;
			// Left Down	(225)
			case JOYSTICK_LEFT	| JOYSTICK_DOWN:
				mvt.MoveLeft();
				mvt.MoveDown();
				break;
			// Right Down	(315)
			case JOYSTICK_RIGHT	| JOYSTICK_DOWN:
				mvt.MoveRight();
				mvt.MoveDown();
				break;
			}
			*/

			// Consume queued actions...

//			if (m_dwqueuedAction & QUEDACTION_RUNMVT)
//				mvt.RunMvt();

			if (m_dwqueuedAction & QUEDACTION_MOVELEFT)
				mvt.MoveLeft();

			if (m_dwqueuedAction & QUEDACTION_MOVERIGHT)
				mvt.MoveRight();

			if (m_dwqueuedAction & QUEDACTION_MOVEUP)
				mvt.MoveUp();

			if (m_dwqueuedAction & QUEDACTION_MOVEDOWN)
				mvt.MoveDown();

			if (m_dwqueuedAction & QUEDACTION_MOVEFORWARD)
				mvt.MoveForward();

			if (m_dwqueuedAction & QUEDACTION_MOVEBACKWARD)
				mvt.MoveBackward();

			if (m_dwqueuedAction & QUEDACTION_ROTATELEFT)
				mvt.RotateLeft();

			if (m_dwqueuedAction & QUEDACTION_ROTATERIGHT)
				mvt.RotateRight();

			if (m_dwqueuedAction & QUEDACTION_STRAFELEFT)
				mvt.StrafeLeft();

			if (m_dwqueuedAction & QUEDACTION_STRAFERIGHT)
				mvt.StrafeRight();

			m_dwqueuedAction					= QUEDACTION_NONE; // End

			// New in v0.3.0 (3): Checking each direction independently to allow for more than 2 directions at the same time
			// or JOYSTICK_FIRE1, JOYSTICK_FIRE2, JOYSTICK_FIRE3, etc. to be pressed at the
			// same time as movement directions for example

			if (m_pMvt->m_dwFlags & MFLAG2_COMPUTERCONTROLLED)
				return; // If the object is computer-controlled, ignore player input

			// Masking the joystick state with the direction bits to ignore any
			// other buttons (like fire buttons) that might be pressed at the same time
			const BYTE	directionState			= this->joystickState &
				(JOYSTICK_LEFT | JOYSTICK_RIGHT | JOYSTICK_UP | JOYSTICK_DOWN);

			// Masking the joystick state with the fire bits to ignore any
			// other buttons (like direction buttons) that might be pressed at the same time
			const BYTE	fireState				= this->joystickState &
				(JOYSTICK_FIRE1 | JOYSTICK_FIRE2 | JOYSTICK_FIRE3 | JOYSTICK_FIRE4);
			const bool	strafeControlActive		= IsTankSideControlActive(m_pMvt->m_dwStrafingControl, fireState);
			const bool	rotationControlActive	= IsTankSideControlActive(m_pMvt->m_dwRotationControl, fireState);

			// If Tank Movement is enabled, the controls are different
			if (m_pMvt->m_dwFlags & MFLAG6_TANKMVT)
			{
				// Forward
				if (directionState & JOYSTICK_UP)
					mvt.MoveForward();

				// Backward
				if (directionState & JOYSTICK_DOWN)
					mvt.MoveBackward();

				// Strafe Left
				if ((directionState & JOYSTICK_LEFT) && strafeControlActive)
				{
					mvt.StrafeLeft();
				}
				// Rotate Left
				else if ((directionState & JOYSTICK_LEFT) && rotationControlActive)
				{
					mvt.RotateLeft();
				}

				// Strafe Right
				if ((directionState & JOYSTICK_RIGHT) && strafeControlActive)
				{
					mvt.StrafeRight();
				}
				// Rotate Right
				else if ((directionState & JOYSTICK_RIGHT) && rotationControlActive)
				{
					mvt.RotateRight();
				}
			}
			// Regular movement
			else
			{
				// Left
				if (directionState & JOYSTICK_LEFT)
					mvt.MoveLeft();

				// Right
				if (directionState & JOYSTICK_RIGHT)
					mvt.MoveRight();

				// Up
				if (directionState & JOYSTICK_UP)
					mvt.MoveUp();

				// Down
				if (directionState & JOYSTICK_DOWN)
					mvt.MoveDown();
			}
		});

	// ... Collision ...

	this->topDownX->SetCollisionCallback([this](Linky::TopDownX& mvt)
		{
			callCollisions(this->m_pHo); // Using the Fusion collision-checking system
		});
}

// Moves the object
// ----------------
BOOL CRunMvtTMO::Move(LPHO pHo)
{
	LPRO pRo = (LPRO)pHo;

	/*
	// Makes the move
	if (pRo->roc.rcSpeed != 0)
	{
		m_segmentCount--;
		if (m_segmentCount <= 0)
		{
			pRo->roc.rcDir += m_dir;
			if (pRo->roc.rcDir >= 32)
				pRo->roc.rcDir -= 32;
			if (pRo->roc.rcDir < 0)
				pRo->roc.rcDir += 32;
			m_segmentCount = m_pMvt->m_dwNOfSegments;
		}
	}
	callAnimations(pHo, ANIMID_WALK);
	callMoveIt(pHo);
	*/

	// If the movement was forced to update (for example by an action), run the movement here
	if (this->forceUpdate)
		this->topDownX->RunMvt();

	// Only move if Move At Start is checked
	if ((m_pMvt->m_dwFlags & MFLAG1_MOVEATSTART) == 0)
	{
		this->topDownX->PlayAnims();	// But still play animations...
		this->forceUpdate = false;		// LETS NOT FORGET TO RESET HERE!!!
		return FALSE;
	}

	// ... Get Joystick State ...

	// MMF2 & F2.5 SDKs had it bugged sighhhhhhhhhh....
	// It typed it rh4Joystick instead of rh4GetJoystick, it also need forward declaration in the header or simply set before.
	//this->joystickState = callGetJoystick(pHo, (int)m_pMvt->m_dwPlayer);

	this->joystickState		= 0;
	if ((m_pMvt->m_dwFlags & MFLAG2_COMPUTERCONTROLLED) == 0)
		this->joystickState = ((pHo->hoAdRunHeader)->rh4.rh4GetJoystick(pHo, (int)m_pMvt->m_dwPlayer));

	// ... Main Update ...

	this->topDownX->dt->CalculateDT();
	if (!this->forceUpdate)
		this->topDownX->RunMvt();		// Prevent running the movement twice in the same frame when it was already forced to update by an action
	this->topDownX->PlayAnims();
	this->forceUpdate = false;			// LETS NOT FORGET TO RESET HERE!!!

	// The object has been moved
	return TRUE;
}

// Changes both X and Y position
// -----------------------------
void CRunMvtTMO::SetPos(LPHO pHo, int x, int y)
{
	/*
	pHo->hoX = (short)x;
	pHo->hoY = (short)y;
	*/

//	pHo->hoX = x;
//	pHo->hoY = y;

	this->topDownX->SetPos(x, y);
}

// Changes X position
// ------------------
void CRunMvtTMO::SetXPosition(LPHO pHo, int x)
{
//	pHo->hoX = (short)x;

//	pHo->hoX = x;

	this->topDownX->SetPosX(x);
}

// Changes Y position
// ------------------
void CRunMvtTMO::SetYPosition(LPHO pHo, int y)
{
//	pHo->hoY = (short)y;

//	pHo->hoY = y;

	this->topDownX->SetPosY(y);
}

// Stops the object
// ----------------
void CRunMvtTMO::Stop(LPHO pHo, BOOL bCurrent)
{
	LPRO pRo = (LPRO)pHo;

	/*
	if (!bCurrent)
	{
		pRo->roc.rcSpeed = 0;
		return;
	}
	int x = 0, y = 0;
	callApproachObject(x, y, pHo, pHo->hoX, pHo->hoY, pRo->roc.rcOldX, pRo->roc.rcOldY, 0, CM_TEST_PLATFORM);
	pHo->hoX = x;
	pHo->hoY = y;
	pRo->roc.rcSpeed = 0;
	*/

	this->topDownX->MarkAsColliding();
}

// Bounces the object
// ------------------
void CRunMvtTMO::Bounce(LPHO pHo, BOOL bCurrent)
{
	/*
	LPRO pRo = (LPRO)pHo;

	if (!bCurrent)
	{
		pRo->roc.rcDir += 16;
		if (pRo->roc.rcDir >= 32)
			pRo->roc.rcDir -= 32;
		m_dir = -m_dir;
		return;
	}
	int x = 0, y = 0;
	callApproachObject(x, y, pHo, pHo->hoX, pHo->hoY, pRo->roc.rcOldX, pRo->roc.rcOldY, 0, CM_TEST_PLATFORM);
	pHo->hoX = x;
	pHo->hoY = y;
	pRo->roc.rcDir += 16;
	if (pRo->roc.rcDir >= 32)
		pRo->roc.rcDir -= 32;
	m_dir = -m_dir;
	*/

	this->topDownX->MarkAsColliding();
	this->topDownX->Bounce();
}

// Go in reverse
// -------------
void CRunMvtTMO::Reverse(LPHO pHo)
{
	/*
	LPRO pRo = (LPRO)pHo;

	pRo->roc.rcDir += 16;
	if (pRo->roc.rcDir >= 32)
		pRo->roc.rcDir -= 32;
	m_dir = -m_dir;
	*/
}

// Restart the movement
// --------------------
void CRunMvtTMO::Start(LPHO pHo)
{
	/*
	LPRO pRo = (LPRO)pHo;

	pRo->roc.rcSpeed = m_pMvt->m_dwSpeed;
	*/
}

// Changes the speed
// -----------------
void CRunMvtTMO::SetSpeed(LPHO pHo, int speed)
{}

// Changes the maximum speed
// -------------------------
void CRunMvtTMO::SetMaxSpeed(LPHO pHo, int speed)
{}

// Changes the direction
// ---------------------
void CRunMvtTMO::SetDir(LPHO pHo, int speed)
{}

// Changes the acceleration
// ------------------------
void CRunMvtTMO::SetAcc(LPHO pHo, int acc)
{}

// Changes the deceleration
// ------------------------
void CRunMvtTMO::SetDec(LPHO pHo, int dec)
{}

// Changes the rotation speed
// --------------------------
void CRunMvtTMO::SetRotSpeed(LPHO pHo, int speed)
{}

// Changes the authorised directions out of 8
// ------------------------------------------
void CRunMvtTMO::Set8Dirs(LPHO pHo, int dirs)
{}

// Changes the gravity
// -------------------
void CRunMvtTMO::SetGravity(LPHO pHo, int gravity)
{}

// SAVE POSITION OF OBJECT
// -----------------------
struct SaveTMO
{
	/*
	bool r_Stopped;
	bool handleDirection;
	double posX;
	double posY;
	double velX;
	double velY;
	double accX;
	double accY;
	double angle;
	double minSpeed;
	double maxSpeed;
	*/

	unsigned int					version				= SAVELOAD_VERSION;
	BYTE							joystickState		= 0;
	Linky::TopDownX::RuntimeState	topDownXState;
};

DWORD CRunMvtTMO::SavePosition(LPHO hoPtr, HANDLE hf)
{
	SaveTMO		save;
	/*
	save.r_Stopped			= r_Stopped;
	save.handleDirection	= handleDirection;
	save.posX				= posX;
	save.posY				= posY;
	save.velX				= velX;
	save.velY				= velY;
	save.accX				= accX;
	save.accY				= accY;
	save.angle				= angle;
	save.minSpeed			= minSpeed;
	save.maxSpeed			= maxSpeed;
	*/

	save.joystickState		= this->joystickState;
	save.topDownXState		= this->topDownX->GetRuntimeState();

	DWORD		written		= 0;
	BOOL		ok			= WriteFile(hf, &save, sizeof(save), &written, NULL);
	return (DWORD)(ok && written == sizeof(save));
}

DWORD CRunMvtTMO::LoadPosition(LPHO hoPtr, HANDLE hf)
{
	SaveTMO		save;

	DWORD		read		= 0;
	if (ReadFile(hf, &save, sizeof(SaveTMO), &read, NULL) && read == sizeof(save))
	{
		/*
		r_Stopped			= save.r_Stopped;
		handleDirection		= save.handleDirection;
		posX				= save.posX;
		posY				= save.posY;
		velX				= save.velX;
		velY				= save.velY;
		accX				= save.accX;
		accY				= save.accY;
		angle				= save.angle;
		minSpeed			= save.minSpeed;
		maxSpeed			= save.maxSpeed;
		*/

		if (save.version	!= SAVELOAD_VERSION)
			return FALSE; // Version mismatch, cannot load

		this->joystickState	= save.joystickState;
		this->topDownX->SetRuntimeState(save.topDownXState);

		return (DWORD)TRUE;
	}
	return FALSE;
}

// Extension Actions entry
// -----------------------
DWORD CRunMvtTMO::ActionEntry(LPHO pHo, int action, DWORD param)
{
	ActionParamPayload* paramPayload = (ActionParamPayload*)param;

	switch (action)
	{
	// Load / save position
	// Doing it like Vector Movement did it...
	case MVTACTION_SAVEPOSITION:
		return SavePosition(pHo, (HANDLE)param);
	case MVTACTION_LOADPOSITION:
		return LoadPosition(pHo, (HANDLE)param);

	// Actions

	case SET_RUNMVT:
	{
//		this->topDownX->RunMvt();
//		m_dwqueuedAction |= QUEDACTION_RUNMVT;
		this->forceUpdate = true;
		break;
	}
	case SET_MOVELEFT:
	{
//		this->topDownX->MoveLeft();
		m_dwqueuedAction |= QUEDACTION_MOVELEFT;
		break;
	}
	case SET_MOVERIGHT:
	{
//		this->topDownX->MoveRight();
		m_dwqueuedAction |= QUEDACTION_MOVERIGHT;
		break;
	}
	case SET_MOVEUP:
	{
//		this->topDownX->MoveUp();
		m_dwqueuedAction |= QUEDACTION_MOVEUP;
		break;
	}
	case SET_MOVEDOWN:
	{
//		this->topDownX->MoveDown();
		m_dwqueuedAction |= QUEDACTION_MOVEDOWN;
		break;
	}
	case SET_MOVEFORWARD:
	{
//		this->topDownX->MoveForward();
		m_dwqueuedAction |= QUEDACTION_MOVEFORWARD;
		break;
	}
	case SET_MOVEBACKWARD:
	{
//		this->topDownX->MoveBackward()
		m_dwqueuedAction |= QUEDACTION_MOVEBACKWARD;
		break;
	}
	case SET_ROTATELEFT:
	{
//		this->topDownX->RotateLeft();
		m_dwqueuedAction |= QUEDACTION_ROTATELEFT;
		break;
	}
	case SET_ROTATERIGHT:
	{
//		this->topDownX->RotateRight();
		m_dwqueuedAction |= QUEDACTION_ROTATERIGHT;
		break;
	}
	case SET_STRAFELEFT:
	{
//		this->topDownX->StrafeLeft();
		m_dwqueuedAction |= QUEDACTION_STRAFELEFT;
		break;
	}
	case SET_STRAFERIGHT:
	{
//		this->topDownX->StrafeRight();
		m_dwqueuedAction |= QUEDACTION_STRAFERIGHT;
		break;
	}
	case SET_MOVEDIR:
	{
		float dir							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetMoveDir(dir);
		break;
	}
	case SET_MOVETODIR:
	{
		this->topDownX->MoveToDir();
		break;
	}
	case SET_MAGNITUDE:
	{
		float dir							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetMagnitude(dir);
		break;
	}
	case SET_APPLYFORCE:
	{
		this->topDownX->ApplyForce();
		break;
	}
	case SET_VELX:
	{
		float velX							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetVelX(velX);
		break;
	}
	case SET_VELY:
	{
		float velY							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetVelY(velY);
		break;
	}
	case SET_VELXY:
	{
		float velX							= DwordBitsToFloat(paramPayload->dwValue1);
		float velY							= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetVelXY(velX, velY);
		break;
	}
	case SET_VELDIR:
	{
		float vel							= DwordBitsToFloat(paramPayload->dwValue1);
		float dir							= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetVelDir(vel, dir);
		break;
	}
	case SET_ADDVELX:
	{
		float addVelX						= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetAddVelX(addVelX);
		break;
	}
	case SET_ADDVELY:
	{
		float addVelY						= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetAddVelY(addVelY);
		break;
	}
	case SET_ADDVELXY:
	{
		float addVelX						= DwordBitsToFloat(paramPayload->dwValue1);
		float addVelY						= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetAddVelXY(addVelX, addVelY);
		break;
	}
	case SET_ADDVELDIR:
	{
		float addVel						= DwordBitsToFloat(paramPayload->dwValue1);
		float dir							= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetAddVelDir(addVel, dir);
		break;
	}
	case SET_FINALVELX:
	{
		float finalVelX						= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetFinalVelX(finalVelX);
		break;
	}
	case SET_FINALVELY:
	{
		float finalVelY						= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetFinalVelY(finalVelY);
		break;
	}
	case SET_FINALVELXY:
	{
		float finalVelX						= DwordBitsToFloat(paramPayload->dwValue1);
		float finalVelY						= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetFinalVelXY(finalVelX, finalVelY);
		break;
	}
	case SET_FINALVELDIR:
	{
		float finalVel						= DwordBitsToFloat(paramPayload->dwValue1);
		float dir							= DwordBitsToFloat(paramPayload->dwValue2);
		this->topDownX->SetFinalVelDir(finalVel, dir);
		break;
	}
	case SET_ACCEL:
	{
		float accel							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetAccel(accel);
		break;
	}
	case SET_DECEL:
	{
		float decel							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetDecel(decel);
		break;
	}
	case SET_SPD:
	{
		float spd							= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetSpd(spd);
		break;
	}
	case SET_BACKWARDSPD:
	{
		float backwardSpd					= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetBackwardSpd(backwardSpd);
		break;
	}
	case SET_ROTSPD:
	{
		float rotSpd = DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetRotationSpeed(rotSpd);
		break;
	}
	case SET_STRAFESPD:
	{
		float strafeSpd						= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetStrafeSpd(strafeSpd);
		break;
	}
	case SET_MVTFACTOR:
	{
		unsigned int	mvtFactor			= paramPayload->dwValue1;
		this->topDownX->SetMvtFactor(mvtFactor);
		break;
	}
	case SET_PRECISIONQUALITY:
	{
		unsigned short	precisionQuality	= (unsigned short)paramPayload->dwValue1;
		this->topDownX->SetPrecisionQuality(precisionQuality);
		break;
	}
	case SET_MOVENCOLLIDESTEPS:
	{
		unsigned int	moveNCollideSteps	= paramPayload->dwValue1;
		this->topDownX->SetMoveNCollideSteps(moveNCollideSteps);
		break;
	}
	case SET_PUSHOUTRADIUSSTEP:
	{
		float pushOutRadiusStep				= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetPushOutRadiusStep(pushOutRadiusStep);
		break;
	}
	case SET_PUSHOUTMAXRADIUS:
	{
		float pushOutMaxRadius				= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetPushOutMaxRadius(pushOutMaxRadius);
		break;
	}
	case SET_PUSHOUTANGLESTEP:
	{
		float pushOutAngleStep				= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetPushOutAngleStep(pushOutAngleStep);
		break;
	}
	case SET_ROTATEANGLEEPSILON:
	{
		float rotateAngleEpsilon			= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetRotateAngleEpsilon(rotateAngleEpsilon);
		break;
	}
	case SET_COLLISIONBOUNCESTRENGTH:
	{
		float collisionBounceStrength		= DwordBitsToFloat(paramPayload->dwValue1);
		this->topDownX->SetCollisionBounceStrength(collisionBounceStrength);
		break;
	}

	// Expressions

	case GET_VEL:
	{
		return FloatToDwordBits(this->topDownX->GetVel());
	}
	case GET_VELX:
	{
		return FloatToDwordBits(this->topDownX->GetVelX());
	}
	case GET_VELY:
	{
		return FloatToDwordBits(this->topDownX->GetVelY());
	}
	case GET_ADDVEL:
	{
		return FloatToDwordBits(this->topDownX->GetAddVel());
	}
	case GET_ADDVELX:
	{
		return FloatToDwordBits(this->topDownX->GetAddVelX());
	}
	case GET_ADDVELY:
	{
		return FloatToDwordBits(this->topDownX->GetAddVelY());
	}
	case GET_TARGETVEL:
	{
		return FloatToDwordBits(this->topDownX->GetTargetVel());
	}
	case GET_TARGETVELX:
	{
		return FloatToDwordBits(this->topDownX->GetTargetVelX());
	}
	case GET_TARGETVELY:
	{
		return FloatToDwordBits(this->topDownX->GetTargetVelY());
	}
	case GET_FINALVEL:
	{
		return FloatToDwordBits(this->topDownX->GetFinalVel());
	}
	case GET_FINALVELX:
	{
		return FloatToDwordBits(this->topDownX->GetFinalVelX());
	}
	case GET_FINALVELY:
	{
		return FloatToDwordBits(this->topDownX->GetFinalVelY());
	}
	case GET_ACCEL:
	{
		return FloatToDwordBits(this->topDownX->GetAccel());
	}
	case GET_DECEL:
	{
		return FloatToDwordBits(this->topDownX->GetDecel());
	}
	case GET_SPD:
	{
		return FloatToDwordBits(this->topDownX->GetSpd());
	}
	case GET_BACKWARDSPD:
	{
		return FloatToDwordBits(this->topDownX->GetBackwardSpd());
	}
	case GET_ROTSPD:
	{
		return FloatToDwordBits(this->topDownX->GetRotationSpeed());
	}
	case GET_STRAFESPD:
	{
		return FloatToDwordBits(this->topDownX->GetStrafeSpd());
	}
	case GET_DIR:
	{
		return FloatToDwordBits(this->topDownX->GetMoveDir());
	}
	case GET_REALDIR:
	{
		return FloatToDwordBits(this->topDownX->GetDir());
	}
	case GET_MAGNITUDE:
	{
		return FloatToDwordBits(this->topDownX->GetMagnitude());
	}
	case GET_MVTFACTOR:
	{
		return (DWORD)this->topDownX->GetMvtFactor();
	}
	case GET_PRECISIONQUALITY:
	{
		return (DWORD)this->topDownX->GetPrecisionQuality();
	}
	case GET_MOVENCOLLIDESTEPS:
	{
		return (DWORD)this->topDownX->GetMoveNCollideSteps();
	}
	case GET_PUSHOUTRADIUSSTEP:
	{
		return FloatToDwordBits(this->topDownX->GetPushOutRadiusStep());
	}
	case GET_PUSHOUTMAXRADIUS:
	{
		return FloatToDwordBits(this->topDownX->GetPushOutMaxRadius());
	}
	case GET_PUSHOUTANGLESTEP:
	{
		return FloatToDwordBits(this->topDownX->GetPushOutAngleStep());
	}
	case GET_ROTATEANGLEEPSILON:
	{
		return FloatToDwordBits(this->topDownX->GetRotateAngleEpsilon());
	}
	case GET_COLLISIONBOUNCESTRENGTH:
	{
		return FloatToDwordBits(this->topDownX->GetCollisionBounceStrength());
	}
	}

	return 0;
}

// Returns the speed
// -----------------
int CRunMvtTMO::GetSpeed(LPHO pHo)
{
	return ((LPRO)pHo)->roc.rcSpeed;	// BUILT-IN SPEED NOT TOPDOWNX SPEED!!!
}

// Returns the acceleration
// ------------------------
int CRunMvtTMO::GetAcceleration(LPHO pHo)
{
	return 0;
}

// Returns the deceleration
// ------------------------
int CRunMvtTMO::GetDeceleration(LPHO pHo)
{
	return 0;
}

// Returns the gravity
// -------------------
int CRunMvtTMO::GetGravity(LPHO pHo)
{
	return 0;
}

// Returns the direction
// -------------------
int CRunMvtTMO::GetDir(LPHO pHo)
{
	return ((LPRO)pHo)->roc.rcDir;		// ANIMATION DIR NOT TOPDOWNX DIR!!!
}


// Reserved for future extension
// -----------------------------
DWORD CRunMvtTMO::Extension(LPHO pHo, int function, DWORD param)
{
	return 0;
}

// Debugger

// -----------------
// GetDebugTree
// -----------------
// This routine returns the address of the debugger tree
//
LPWORD CRunMvtTMO::GetDebugTree()
{
	return this->m_pMvt->DebugTree;
}

// -----------------
// GetDebugItem
// -----------------
// This routine returns the text of a given item.
//
void CRunMvtTMO::GetDebugItem(LPTSTR pBuffer, int id)
{
	// Example
	// -------
/*
	char temp[DB_BUFFERSIZE];

	switch (id)
	{
	case DB_CURRENTSTRING:
		LoadString(hInstLib, IDS_CURRENTSTRING, temp, DB_BUFFERSIZE);
		wsprintf(pBuffer, temp, rdPtr->text);
		break;
	case DB_CURRENTVALUE:
		LoadString(hInstLib, IDS_CURRENTVALUE, temp, DB_BUFFERSIZE);
		wsprintf(pBuffer, temp, rdPtr->value);
		break;
	case DB_CURRENTCHECK:
		LoadString(hInstLib, IDS_CURRENTCHECK, temp, DB_BUFFERSIZE);
		if (rdPtr->check)
			wsprintf(pBuffer, temp, _T("TRUE"));
		else
			wsprintf(pBuffer, temp, _T("FALSE"));
		break;
	case DB_CURRENTCOMBO:
		LoadString(hInstLib, IDS_CURRENTCOMBO, temp, DB_BUFFERSIZE);
		wsprintf(pBuffer, temp, rdPtr->combo);
		break;
	}
*/

	TCHAR temp[DB_BUFFERSIZE];

	switch (id)
	{
	case DB_GROUPTOPDOWNX:
		LoadString(hInst, IDS_MVTTMO_DB_GROUPTOPDOWNX,		temp, DB_BUFFERSIZE);
		wsprintf(pBuffer, temp);
		break;
	case DB_VELX:
		LoadString(hInst, IDS_MVTTMO_DB_VELX,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetVelX());
		break;
	case DB_VELY:
		LoadString(hInst, IDS_MVTTMO_DB_VELY,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetVelY());
		break;
	case DB_ADDVELX:
		LoadString(hInst, IDS_MVTTMO_DB_ADDVELX,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetAddVelX());
		break;
	case DB_ADDVELY:
		LoadString(hInst, IDS_MVTTMO_DB_ADDVELY,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetAddVelY());
		break;
	case DB_TARGETVELX:
		LoadString(hInst, IDS_MVTTMO_DB_TARGETVELX,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetTargetVelX());
		break;
	case DB_TARGETVELY:
		LoadString(hInst, IDS_MVTTMO_DB_TARGETVELY,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetTargetVelY());
		break;
	case DB_FINALVELX:
		LoadString(hInst, IDS_MVTTMO_DB_FINALVELX,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetFinalVelX());
		break;
	case DB_FINALVELY:
		LoadString(hInst, IDS_MVTTMO_DB_FINALVELY,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetFinalVelY());
		break;
	case DB_ACCEL:
		LoadString(hInst, IDS_MVTTMO_DB_ACCEL,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetAccel());
		break;
	case DB_DECEL:
		LoadString(hInst, IDS_MVTTMO_DB_DECEL,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetDecel());
		break;
	case DB_SPD:
		LoadString(hInst, IDS_MVTTMO_DB_SPD,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetSpd());
		break;
	case DB_ROTSPD:
		LoadString(hInst, IDS_MVTTMO_DB_ROTSPD,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetRotationSpeed());
		break;
	case DB_DIR:
		LoadString(hInst, IDS_MVTTMO_DB_DIR,				temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetMoveDir());
		break;
	case DB_REALDIR:
		LoadString(hInst, IDS_MVTTMO_DB_REALDIR,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetDir());
		break;
	case DB_MAGNITUDE:
		LoadString(hInst, IDS_MVTTMO_DB_MAGNITUDE,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetMagnitude());
		break;
	case DB_MVTFACTOR:
		LoadString(hInst, IDS_MVTTMO_DB_MVTFACTOR,			temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetMvtFactor());
		break;
	case DB_PRECISIONQUALITY:
		LoadString(hInst, IDS_MVTTMO_DB_PRECISIONQUALITY,	temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetPrecisionQuality());
		break;
	case DB_MOVENCOLLIDESTEPS:
		LoadString(hInst, IDS_MVTTMO_DB_MOVENCOLLIDESTEPS,	temp, DB_BUFFERSIZE);
		StringCchPrintf(pBuffer, DB_BUFFERSIZE, temp, (double)this->topDownX->GetMoveNCollideSteps());
		break;
	}
}

// -----------------
// EditDebugItem
// -----------------
// This routine allows to edit editable items.
//
// Note: Something is wrong with this function, id is always 1, even when clicking on other items.
// Maybe a problem with the debugger tree or just a Fusion bug?
void CRunMvtTMO::EditDebugItem(int id)
{
	// Example
	// -------
/*
	switch (id)
	{
	case DB_CURRENTSTRING:
		{
			EditDebugInfo dbi;
			char buffer[256];

			dbi.pText=buffer;
			dbi.lText=TEXT_MAX;
			dbi.pTitle=NULL;

			strcpy(buffer, rdPtr->text);
			long ret=callRunTimeFunction(rdPtr, RFUNCTION_EDITTEXT, 0, (LPARAM)&dbi);
			if (ret)
				strcpy(rdPtr->text, dbi.pText);
		}
		break;
	case DB_CURRENTVALUE:
		{
			EditDebugInfo dbi;

			dbi.value=rdPtr->value;
			dbi.pTitle=NULL;

			long ret=callRunTimeFunction(rdPtr, RFUNCTION_EDITINT, 0, (LPARAM)&dbi);
			if (ret)
				rdPtr->value=dbi.value;
		}
		break;
	}
*/

	switch (id)
	{
	case DB_VELX - DB_GROUPTOPDOWNX:
		{
			TCHAR			pTitle[DB_BUFFERSIZE];
			LoadString(hInst, IDS_MVTTMO_DB_VELX_INFO, pTitle, DB_BUFFERSIZE);

			EditDebugInfo	dbi;
			int				value		= this->topDownX->GetVelX();
			dbi.value					= value;
			dbi.pTitle					= pTitle;
			long ret					= callRunTimeFunction2(this->m_pHo, RFUNCTION_EDITINT, 0, (LPARAM)&dbi);
			if (ret)
				this->topDownX->SetVelX(dbi.value);
		}
		break;
	case DB_VELY - DB_GROUPTOPDOWNX:
		{
			TCHAR			pTitle[DB_BUFFERSIZE];
			LoadString(hInst, IDS_MVTTMO_DB_VELY_INFO, pTitle, DB_BUFFERSIZE);

			EditDebugInfo	dbi;
			int				value		= this->topDownX->GetVelY();
			dbi.value					= value;
			dbi.pTitle					= pTitle;
			long ret					= callRunTimeFunction2(this->m_pHo, RFUNCTION_EDITINT, 0, (LPARAM)&dbi);
			if (ret)
				this->topDownX->SetVelY(dbi.value);
		}
		break;

		// No need to continue for now...
	}
}