CBinBuffer : public vector<Uint8>

CBinBuffer is our standard binary container class.

• operator+=(const type); //for various types
• gettype(); //for various types

CMessageBuffer : public CBinBuffer

CMessageBuffer is an advanced CBinBuffer, special for CMessages. It contains a header and message-specific data. header+data is called buffer.

• CMessageBuffer::eMessageType getType();
//e.g. car input, car parameters, or cow input :-)
• bool setType(const CMessageBuffer::eMessageType);
• CBinBuffer & getData() const;
• bool setData(CBinBuffer &);
• CBinBuffer & getBuffer();
• bool setBuffer(const CBinBuffer &);

CMessage

CMessage is a base-class for all kinds of messages: e.g. input data from a player to its moving object, or dynamic object parameter data. Data can be converted to a binary representation using the getBuffer method. Derived classes might want to overload getBuffer and setBuffer in order to adapt the behaviour of the object. They probably also overload the getType method.

• CMessage();
• CMessage(CMessageBuffer);
• CMessageBuffer getBuffer();
• bool setBuffer(const CMessageBuffer &);
• eMessageType getType() const;

CObjectChoice

An ObjectChoice message is used to describe what kind of moving object is desired by a player. This includes the kind of object (car, train, cow etc.), the type (e.g. the car model) and additional settings.

• eMessageType m_ObjType;
• CString m_Filename;

CMovObjInput : CMessage

Input data coming from a player and going to a moving object. Input data is handled in a general way using the four float properties.

• float m_Up, m_Forward, m_Backward, m_Right;

CCarInput : CMovObjInput

Input data coming from a player and going to a CCar object. Derived from CMovObjInput. Steering data is sent via m_Right, gas data via m_Forward, brake data via m_Backward and m_Up is not used.

• Uint8 m_Gear;
• bool m_CarHorn;

CMaterial

CMaterial provides material-properties, like the static & dynamic friction coefficients. It also contains data for other subsytems of the game, like the location of a corresponding texture file.

• bool loadFromFile(CString filename, int mul);
• CString getFilename();
• int getTextureMul();

• CString

CShape

CShape provides a vertex-based collision model. It also contains data for other subsytems of the game, like the location of the geometry file.

• bool loadFromFile(CString filename, CString subset);
• CString getFilename();
• CString getSubset();

• CString

CBound

CBound provides a plane-based collision model. It also contains data for other subsytems of the game, like the location of the geometry file.

• bool loadFromFile(CString filename);
• CString getFilename();

• CString

CTile

CTile is the elementary data type of which a track is built. The track actually is an array of this type. The place in the array, together with the m_Z property define the position of the tile, while the m_R property defines the orientation. The m_Shape property is an index of an element of the shapes-array.

• int m_Z, m_R, m_Shape;

CBody

A part of a physical object. The bodies of a physical object are rigid bodies, and they can move relative to each other. The m_Position and m_Orientation properties define the position and orientation of the body, and the m_Body property is the index of an element of the bound-array.

• int m_Body;
• CVector m_Position;
• CMatrix m_Orientation;

• CVector
• CMatrix

CDynamicObject : public CMessage

Implementation of a dynamic object. It is derived from CMessage, so that its parameters can be get/set via the get/setBuffer methods. Input data of this object can be reached via m_InputData. Players/network interfaces can set this, and simulations/network interfaces can read it. The constructor of the derived classes should create a m_InputData of the right type.
As this class is used for physical objects, m_Bodies and m_Sounds have been added.

• CMessage *m_InputData;
• bool hasChanged();
• vector<CBody> m_Bodies;
• vector<int> m_Sounds;

CMovingObject : public CDynamicObject

Implementation of the moving object as described in the definitions. Various methods provide a vector-based version of the position-data. Derived classes may have additional parameters. If so, they have to provide their own getBuffer and setBuffer overload methods.
By default, CMovingObject uses a m_InputData of the type CMovObjInput.
The simulate method simulates the type-dependent physics of the moving object.

• void simulate(CPhysics &)

//Gets+sets for position parameters
• CVector getPosition();
• void setPosition(CVector);
• CVector getVelocity();
• void setVelocity(CVector);
• CVector getOrientation();
• void setOrientation(CVector);
• CVector getAngularVelocity();
• void setAngularVelocity(CVector);

• const CMatrix &getRotationMatrix();
• void setRotationMatrix(CMatrix &m);

//Additional get for approximation model
• CVector getAcceleration();

• float m_Mass;

CCar : public CMovingObject

CCar is a class derived from CMovingObject. The m_InputData member is of the type CCarInput.

• CVector m_FrontWheelNeutral, m_BackWheelNeutral;
• float m_WheelRadius;
• float m_WheelVelocity, m_WheelAngle;
• float m_WheelHeight1, ...;

CWorld

Implementation of the "world" as described in the definitions.

• bool loadTrack(CString filename);
• void unloadTrack();
• vector<CTile> m_Track;
• int m_L, m_W, m_H;

• bool loadMovObjs(CString filename);
• void unloadMovObjs();
• vector<CMovingObject *> m_MovObjs;

• vector<CShape *> m_TileShapes;
• vector<CBound *> m_MovObjBounds;
• vector<CMaterial *> m_TileMaterials;
• vector<CMaterial *> m_MovObjMaterials;
• vector<CString> m_MovObjSounds;
• CString getBackgroundFilename();

• ...(other objects, like a chat radio)

CPlayer

Base-class for all players. On initialisation, the world object should be given to the player. When the object is registered by a CPlayerControl-object, the m_MovingObjectId and m_PlayerId should be set.
When update() is called, the player-object is allowed to think about its intelligent response, and it writes its actions to the m_InputData of its CMovingObject.

• CPlayer(const CWorld *w);
• bool update(); //Returns true if input data has changed
• int m_MovingObjectId; //Index of moving object being controlled
• int m_PlayerId; //Index of player. Set by CSimulation.

CAIPlayerCar : public CPlayer

Implementation of a local AI player, specialised in controlling cars.

CClientNet : public CFileCtrl

CClientNet is the client-side implementation of the network protocol. It is derived from CFileCtrl, so that it can manage file downloads.

• CClientNet(CString host, int port);
• bool connect(); //returns true on succes
• bool hasSlowConectionType(); //needed to decide if approximation or physics should be created

CServerNet

CServerNet is the server-side implementation of the network protocol.

• bool startListening(int port, int max_new_clients);
• void setClientPolicy(int max_new_clients);

CSimulation

Base-class for all simulations. A CSimulation-object should be used as follows:

• Create a CWorld object
• Construct the CSimulation, using the CWorld object
• Load the track into the CWorld-object
• Add players to the game
• During the game, call update() frequently

• CSimulation(CWorld *);
• bool update(); //returns false if game has stopped

CPhysics : public CSimulation

CSimulation-class doing the "real" physics calculations.

CApproximation : public CSimulation

CSimulation-class approximating physics with some fast calculations.

CClientSim : public CSimulation

CSimulation-class to be used in client-programs. Connects to the server program and synchronises the world-data frequently. CClientSim does not simulate any physics, but it can be used together with CPhysics or CApproximation. To choose between them, use the CClientNet::hasSlowConectionType() method.

• CClientSim(CClientNet *, CWorld *);
• CString getTrackName();

CRuleControl : public CSimulation

CRuleControl checks if players are following the right route, gives them penalty time, checks if theyre finished, etc. This simulation can be used together with CPhysics in a server program or in a local game.

CPlayerControl

CPlayerControl is used to manage the players in a game session. With the addPlayer method, an integer is returned, which can be put in the m_PlayerId property of a CPlayer object. A negative value means that the adding was not succesful, for example, because it was refused by the server. After all local players have been added with addPlayer, the loadObjects method should be called. This will load the moving objects of all players into the world object.
The default implementation is suitable for local games.

• CPlayerControl(CWorld *w);
• int addPlayer(CObjectChoice);
• bool loadObjects();

CClientPlayerControl : CPlayerControl

An implementation of CPlayerControl based on communication with a server, for use on the client-side of non-local game sessions.

• CClientPlayerControl(CClientNet *, CWorld *w);