Restructured project structure to use a singular SLN; made the T2API common to all projects; adjusted watchdog timer to 8 seconds

CommonAPI/Common/include/DXAPI/DXAPI.h

@@ -0,0 +1,47 @@
+/**
+ *	@file DXAPI.h
+ *	@brief The DXAPI is an API that allows you to manipulate various game objects 
+ *	in Tribes 2 from raw C++ code. It dynamically resolves the addresses of member
+ *	variables as you can't really trust the compiler to produce binary compatible classes,
+ *	especially with all the inheritance involved in the original Tribes 2 codebase.
+ *
+ *	This code wouldn't be possible without Linker's original gift on the-construct.net forums,
+ *	whose files are appropriately labelled in this codebase. These files have been edited where
+ *	appropriate in order to make that code play better with the DXAPI.
+ *
+ *	@copyright (c) 2014 Robert MacGregor
+ */
+ 
+//#pragma once
+
+#include "LinkerAPI.h"
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/GameBase.h>
+#include <DXAPI/NetObject.h>
+#include <DXAPI/Player.h>
+#include <DXAPI/Projectile.h>
+#include <DXAPI/SceneObject.h>
+#include <DXAPI/ShapeBase.h>
+#include <DXAPI/SimObject.h>
+#include <DXAPI/StaticShape.h>
+#include <DXAPI/GrenadeProjectile.h>
+#include <DXAPI/FlyingVehicle.h>
+#include <DXAPI/GameConnection.h>
+#include <DXAPI/NetConnection.h>
+#include <DXAPI/TCPObject.h>
+#include <DXAPI/ScriptObject.h>
+
+namespace DX
+{
+	//! A typedef referring to some type of unresolved object in the game.
+	typedef void* UnresolvedObject;
+
+	const char *GetModPaths(void);
+	bool IsFile(const char *filename);
+
+	bool GetRelativePath(const char *filename, char *ret, int buffer_length);
+	bool GetRunningMod(char *ret, int buffer_length);
+
+	bool SanitizeFileName(char *ret, int buffer_length);
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/FlyingVehicle.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <DXAPI/Vehicle.h>
+
+namespace DX
+{
+	//! Class representing a FlyingVehicle in the game.
+	class FlyingVehicle : public Vehicle
+	{
+	public:
+		FlyingVehicle(unsigned int obj);
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/GameBase.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <DXAPI/SceneObject.h>
+   enum GameBaseMasks {
+      InitialUpdateMask =     1 << 0,
+      DataBlockMask =         1 << 1,
+      ExtendedInfoMask =      1 << 2,
+      NextFreeMask =          ExtendedInfoMask << 1
+   };
+namespace DX
+{
+	class GameBase : public SceneObject
+	{
+
+	public:
+		GameBase(unsigned int obj);
+		void setProcessTicks(bool proc);
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/GameConnection.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/NetConnection.h>
+#include <LinkerAPI.h>
+#include <DXAPI/ShapeBase.h>
+
+namespace DX
+{
+	class GameConnection : public NetConnection
+	{
+	public:
+		GameConnection(unsigned int obj);
+
+		ShapeBase getControlObject(void);
+		
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/GrenadeProjectile.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/Projectile.h>
+
+namespace DX
+{
+	class GrenadeProjectile : public Projectile
+	{
+	public:
+		GrenadeProjectile(unsigned int obj);
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/NetConnection.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/SimObject.h>
+#include <DXAPI/NetObject.h>
+#include <LinkerAPI.h>
+struct GhostInfo;
+namespace DX
+{
+	class NetConnection : public SimObject
+	{
+	public:
+		NetConnection(unsigned int obj);
+		S32 getGhostIndex(NetObject obj);
+		unsigned char getGhostFrom();
+		unsigned char getGhostTo();
+		NetObject resolveGhostParent(S32 id);
+		NetObject resolveGhost(S32 id);
+		unsigned int actualbaseptr;
+		GhostInfo * mGhostRefs;
+		NetObject **mLocalGhosts;
+	};
+} // End NameSpace DX
+struct GhostRef;
+struct GhostInfo
+{
+ //  public:  // required for MSVC
+
+   // NOTE:
+   // if the size of this structure changes, the
+   // NetConnection::getGhostIndex function MUST be changed 
+   // to reflect.
+   
+   U32 *obj;            // the real object
+   U32 updateMask;         // 32 bits of object info
+   GhostRef *updateChain;     // chain of updates for this object in packets
+   GhostInfo *nextObjectRef;  // next ghost ref for this object (another connection)
+
+   GhostInfo *prevObjectRef;  // prev ghost ref for this object
+   U32 *connection;
+   GhostInfo *nextLookupInfo;
+   U32 updateSkipCount;
+   
+   U32 flags;
+   F32 priority;
+   U32 index;
+   U32 arrayIndex;
+
+	enum Flags
+	{
+		Valid = BIT(0),
+		InScope = BIT(1),
+      ScopeAlways = BIT(2),
+      NotYetGhosted = BIT(3),
+      Ghosting = BIT(4),
+      KillGhost = BIT(5),
+      KillingGhost = BIT(6),
+      ScopedEvent = BIT(7),
+      ScopeLocalAlways = BIT(8),
+	};
+};
+	struct GhostRef
+   {
+      U32 mask;
+      U32 ghostInfoFlags;
+      GhostInfo *ghost;
+      GhostRef *nextRef;
+      GhostRef *nextUpdateChain;
+   };

CommonAPI/Common/include/DXAPI/NetObject.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <DXAPI/SimObject.h>
+
+namespace DX
+{
+	enum NetFlags
+	{
+		IsGhost = 1,
+		ScopeAlways = 1 << 6,
+		ScopeLocal = 1 << 7,
+		Ghostable = 1 << 8
+	};
+
+	class NetObject : public SimObject
+	{
+	public:
+		NetObject(unsigned int obj);
+
+		unsigned int &net_flags;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/Player.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/ShapeBase.h>
+
+namespace DX
+{
+	//! Class representing a player object in the game.
+	class Player : public ShapeBase
+	{
+	public:
+		Player(unsigned int obj);
+
+		//! Object Name
+		const char *name;
+		//! Object ID
+		const unsigned int &id;
+
+		//! Player Object Jetting State (readonly, writing it doesn't do anything)
+		const bool &is_jetting;
+		//! Player Object Jumping State (readonly, writing it doesn't do anything)
+		const bool &is_jumping;
+		//! Player Object Using Toggable Pack
+		bool &is_using_toggledpack;
+
+		//! Player Velocity.
+		Point3F velocity;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/Point3F.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace DX
+{
+	/**
+	 *	@brief A class representing a referenced 3D vector of floats in Tribes 2.
+	 */
+	class Point3F
+	{
+	public:
+		Point3F(float &X, float &Y, float &Z);
+
+		float &x;
+		float &y;
+		float &z;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/Projectile.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/GameBase.h>
+
+#include <LinkerAPI.h>
+
+namespace DX
+{
+	class Projectile : public GameBase
+	{
+	public:
+		Projectile(unsigned int obj);
+
+		void explode(const Linker::Point3F &position, const Linker::Point3F &normal, const unsigned int collideType);
+
+		//! Velocity. It is constant because modifying it directly breaks the sim.
+		const Point3F velocity;
+
+		bool &hidden;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/SceneObject.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/NetObject.h>
+
+namespace DX
+{
+	class SceneObject : public NetObject
+	{
+	public:
+		SceneObject(unsigned int obj);
+
+		Point3F position;
+		Point3F scale;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/ScriptObject.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <DXAPI/SimObject.h>
+
+namespace DX
+{
+	class ScriptObject : public SimObject
+	{
+	public:
+		ScriptObject(unsigned int obj);
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/ShapeBase.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <DXAPI/GameBase.h>
+
+namespace DX
+{
+	class ShapeBase : public GameBase
+	{
+	public:
+		ShapeBase(unsigned int obj);
+		float &cloak_level;
+		bool &cloaked;
+		//! Heat Level
+		float &heat_level;
+		void setMaskBits(int value);
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/SimObject.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace DX
+{
+	class SimObject
+	{
+	public:
+		SimObject(unsigned int obj);
+
+		void deleteObject(void);
+		const char *CallMethod(const char *name, unsigned int argc, ...);
+
+		const unsigned int &identifier;
+		const unsigned int base_pointer_value;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/StaticShape.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <DXAPI/Point3F.h>
+#include <DXAPI/ShapeBase.h>
+
+namespace DX
+{
+	//! Class representing a StaticShape in the game.
+	class StaticShape : public ShapeBase
+	{
+	public:
+		StaticShape(unsigned int obj);
+
+		//! Object Name
+		//const char *name;
+		//! Position
+		//const Point3F position;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/TCPObject.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <DXAPI/SimObject.h>
+
+namespace DX
+{
+	class TCPObject : public SimObject
+	{
+	public:
+		TCPObject(unsigned int obj);
+
+		unsigned int &state;
+	};
+} // End NameSpace DX

CommonAPI/Common/include/DXAPI/Vehicle.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <DXAPI/ShapeBase.h>
+
+namespace DX
+{
+	//! Class representing a FlyingVehicle in the game.
+	class Vehicle : public ShapeBase
+	{
+	public:
+		Vehicle(unsigned int obj);
+	};
+} // End NameSpace DX