#ifndef ENTITY_H #define ENTITY_H // Class Created By: Sam Shannon. #include #include using std::cout; using std::endl; #include "irrlicht.h" using namespace irr; #include "IrrUtils.h" /** \brief A class used to handle Entity(things the player can 'pick up') based data. All Entities created are of this class-type. */ class Entity { public: /** Default constructor */ Entity() {} /** Default destructor */ virtual ~Entity() {} /** \brief A subroutine which allows the setting of the Entity's Position. * \param newPos is the new Position of the Entity */ void setPosition( core::vector3df newPos ); /** \brief A subroutine which allows the setting of the Entity's Rotation. * \param newRot is the new Rotation of the Entity. */ void setRotation( core::vector3df newRot ); /** \brief A subroutine which allows the setting of the Entity's Type. * \param newType is the new Type of the Entity. */ void setType( char newType ); /** \brief A subroutine which allows the setting of the Entity's Subtype. * \param newSubtype is the new Subtype of the Entity. */ void setSubtype( char newSubtype ); /** \brief A subroutine which allows the setting of the Entity's Value. * \param newVal is the new Value of the Entity. */ void setValue( int newVal ); /** \brief A subroutine which allows the setting of the Entity's Mesh. * \param newMesh is the pointer to the Entity's Mesh. */ void setEntityMesh( scene::IMeshSceneNode* newMesh ); /** \brief A subroutine which allows the setting of the Entity's respawn time. * \param newTimer is the value to test against the game time. */ void setEntityTimer(unsigned int newTimer); /** \brief A function which will return the Position of the Entity. * \return The Entity's Position as a core::vector3df */ core::vector3df getPosition(); /** \brief A function which will return the Rotation of the Entity. * \return The Entity's Rotation as a core::vector3df */ core::vector3df getRotation(); /** \brief A function which will return the Type of the Entity. * \return The Entity's Type as a char[1] */ char getType(); /** \brief A function which will return the Subtype of the Entity. * \return The Entity's Subtype as a char[1] */ char getSubtype(); /** \brief A function which will return the Value of the Entity. * \return The Entity's Value as an int */ int getValue(); /** \brief A function which will return a pointer to the Mesh associated with the Entity. * \return The Mesh associated with the Entity as a scene::IMeshSceneNode* */ scene::IMeshSceneNode* getEntityMesh(); /** \brief A function which will return the time of reactivation for the Entity. * \return The point in time at which the Entity should reactivate. */ unsigned int getEntityTimer(); protected: //! A variable which stores the Entity's Position. core::vector3df position; //! A variable which stores the Entity's Rotation. core::vector3df rotation; //! A variable which stores the Entity's Type (This will determine which aspect of the Player's Stats the Entity will affect). //! Possible Types are: 'a' for Ammo, 'p' for Powerup, 'f' for Flag and 'b' for Body. char type; //! A variable which stores the Entity's Subtype (This will determine a more specific aspect of the currently specified [Type] to affect). //! Possible Subtypes are: The first letter of each weapon for that type of ammo ('r' for Rifle), The first letter of each powerup for that type of Power, the letter 'h' for health and 'a' for armour. char subtype; //! A variable which stores the Entity's Value (This will determine the actual affect the Entity will have on the specified [Subtype] of the specified [Type] of the Player's Stats) int value; //! A variable which stores the pointer to the loaded mesh that is representing the Entity. scene::IMeshSceneNode* entityMesh; //! A variable which stores the point in time at which the Entity becomes active again. unsigned int respawnTime; private: }; #endif // ENTITY_H

#ifndef PLAYER_H #define PLAYER_H #include <string> #include <iostream> using std::cout; using std::endl; #include "irrlicht.h" using namespace irr; #include "IrrUtils.h" #include <NetworkIDObject.h> /** \brief A class used to store Player-related data. An object of this class type is created in GameMgr.h and is therefore accessible across all game states. */ class Player : public RakNet::NetworkIDObject { protected: //! The name of the Player. std::string name; //! The ID of the Player. int playerID; //! The location of the mesh file for the Player. io::path playerModelMesh; //! The location of the texture file for the Player. io::path playerModelTexture; //! The position of the Player. core::vector3df position; //! The rotation of the Player. core::vector3df rotation; //! Whether the Player is considered 'dead' or not(bool). bool dead; //! An enumeration of the various powerups available to be applied to the Player. enum Powerups { powerup1, powerup2, powerup3, }; //! An enumeration of the various weapons the player could have selected. enum WeaponSelection { weaponRifle = 1, weaponPistol, weaponGatling, weaponBlunderbuss, }; public: /** Default inline constructor */ //! Initialises 'constants' which aren't actual constants, but will not change past this point. Player() { Rifle.weaponID = 1; Rifle.weaponAvailability = true; Rifle.weaponName = "Rifle"; Rifle.maximumClip = MAX_CLIP_RIFLE; Rifle.weaponModelMesh = "media/meshes/reconfiguredAnimations/rifle.b3d"; Rifle.weaponModelTexture = "media/textures/rifleTexture.png"; Pistol.weaponID = 2; Pistol.weaponAvailability = false; Pistol.weaponName = "Pistol"; Pistol.maximumClip = MAX_CLIP_PISTOL; Pistol.weaponModelMesh = "media/meshes/reconfiguredAnimations/pistols.b3d"; Pistol.weaponModelTexture = "media/textures/pistolTexture.png"; Gatling.weaponID = 3; Gatling.weaponAvailability = false; Gatling.weaponName = "Gatling"; Gatling.maximumClip = MAX_CLIP_GATLING; Gatling.weaponModelMesh = "media/meshes/reconfiguredAnimations/gattling.b3d"; Gatling.weaponModelTexture = "media/textures/gattlingTexture.png"; Blunderbuss.weaponID = 4; Blunderbuss.weaponAvailability = false; Blunderbuss.weaponName = "Blunderbuss"; Blunderbuss.maximumClip = MAX_CLIP_BLUNDERBUSS; Blunderbuss.weaponModelMesh = "media/meshes/reconfiguredAnimations/blunderbuss.b3d"; Blunderbuss.weaponModelTexture = "media/textures/blunderbussTexture.png"; Imperial = true; Rebel = false; } /** Default inline destructor */ virtual ~Player() {} //! A constant value representing the clip size of the Rifle. const static int MAX_CLIP_RIFLE = 8; //! A constant value representing the clip size of the Pistol. const static int MAX_CLIP_PISTOL = 16; //! A constant value representing the clip size of the Gattling Gun. const static int MAX_CLIP_GATLING = 100; //! A constant value representing the clip size of the Blunderbuss. const static int MAX_CLIP_BLUNDERBUSS = 6; //! A constant value representing the maximum amount of health the player can have. const static int MAX_HEALTH = 150; //{ Different Teams //! Whether the Player is on team 0 or 1 (false or true). bool team; //! A Boolean Value, set to true in the constructor and never changed again. bool Imperial; //! A Boolean Value, set to false in the constructor and never changed again. bool Rebel; //} //! A variable to hold the Player's total health. int health; //! A variable to hold the Player's total available ammunition. int ammo; //! A variable to hold the current amount of ammunition in the Player's clip. int clip; //! A variable to hold a representation of which weapon the Player currently has selected. int weaponSelected; //! A variable to hold a representation of whether the Player currently has a flag. bool carryingFlag; //! A variable to hold the value of the currently held flag. int flagValue; /** \brief A function to return whether or not the Player is 'in a state of death'. * \return True if player is dead, else false. */ bool isDead(); /** \brief A subroutine to be called when the player's clip is empty, or when a key is pressed. * Subtracts enough from the total ammunition to refill the current clip size to it's maximum. * \return NULL. */ void reload(); /** \brief A function to determine whether a certain projectile collides with the player. * \param trajectory of the projectile in the form of a core::line3d<f32>. * \return whether or not it hit in the form of a boolean. * */ bool isHit( core::line3d<f32> trajectory ); /** \brief A function to return the Player's name * \return The Player's name in a std::string. */ std::string getName(); /** \brief A function to return the Player's ID. * \return The Player's ID in int form. */ int getID(); /** \brief A function to return the Player's position. * \return The Player's position, in point form, as a core::vector3df. */ core::vector3df getPosition(); /** \brief A function to return the Player's rotation(Absolute). * \return The Player's Absolute rotation as a core::vector3df */ core::vector3df getRotation(); /** \brief A function to return the Player's team. * \return Whether the Player's team is team true or false as a bool. */ bool getTeam(); /** \brief A function to return the Player's health. * \return Player's current health as an int. */ int getHealth(); /** \brief A function to return the Player's current weapon's total Ammunition. * \return The Player's overall ammunition for the currently selected weapon as int. */ int getAmmo(); /** \brief A function to return the Player's current weapon's current clip. * \return The Player's current clip-size for the currently selected weapon as an int. */ int getClip(); /** \brief A function to return whether the Weapon being tested is valid for use by the Player. * \param weaponTest as an int, to be used to specify which Weapon's validity is being tested * \return the tested Weapon's validity for use as a bool. */ bool getWeaponAvailability(int weaponTest); /** \brief A subroutine to apply availability(or lack thereof) to a specific weapon. * \param weapon as an int, the numeric identifier of a certain weapon. * \param availability as a bool, the new availability of the previously specified weapon. */ void setWeaponAvailability(int weapon, bool availability); /** \brief A subroutine to apply damage to the Player. * \param damageTaken as an int, removed directly from the health variable. */ void takeDamage( int damageTaken ); /** \brief A subroutine to increase the Player's avaibale ammunition for the selected weapon. * \param ammoDrop as an int, to be added to the total ammunition of the [weaponType]. * \param weaponType as an int, the number which denotes which type of weapon ammo to increase. */ void pickupAmmo( int ammoDrop, int weaponType ); /** \brief A subroutine to increase the Player's available Health. * \param healthDrop as an int, to be added to the total health of the Player. */ void pickupHealth( int healthDrop ); /** \brief A subroutine to specify that a flag has been acquired, and how much it is worth * \param newFlagVal as an int, to be used to increment the score when the player reaches their own flag. */ void pickupFlag( int newFlagVal ); /** \brief A subroutine to specify that the player no-longer has the enemy flag. * \param newFlagVal as an int, to increment the player's score if dropped within the confines of the target area. */ void dropFlag(); /** \brief A subroutine to set the Player's name. */ void setName( std::string playerName ); /** \brief A subroutine to set the Player's ID. * \param id as an int. */ void setID( int id ); /** \brief A subroutine to set whether the Player has died. * \param hasDied as a bool. */ void setDead( bool hasDied ); /** \brief A subroutine to set the Player's team. * \param onTeam as a bool. */ void setTeam( bool onTeam ); /** \brief A subroutine to set the Player's total available ammunition for the selected weapon. * \param currentAmmo of the current weapon as an int. */ void setAmmo( int currentAmmo ); /** \brief A subroutine to set the Player's position. * \param newPos as a core::vector3df. */ void setPosition( core::vector3df newPos ); /** \brief A subroutine to set the Player's rotation. * \param newRot as a core::vector3df. */ void setRotation( core::vector3df newRot ); /** \brief A function to return the Player's currently selected weapon. * \return int representation of the selected weapon (use the WeaponSelection enum to associate the number with an intrinsic weapon name). */ int getSelectedWeapon(); /** \brief A subroutine to set the Player's currently selected weapon. * \param selection as an int (use the WeaponSelection enum to associate the number with an intrinsic weapon name). */ void setSelectedWeapon( int selection ); /** \brief A subroutine to set the Player's currently selected weapon's clip size. * \param newClip int */ void setClip( int newClip ); /** \brief A structure containing information specific to each weapon. Each weapon will have an object of this class type created under it's name. */ struct Weapon { //! A variable to hold the weapon's ID. int weaponID; //! A variable to hold the weapon's Name. std::string weaponName; //! A variable to hold whether they player has access to the weapon. bool weaponAvailability; //! A variable to hold the weapon's (total)Ammunition. int totalAmmo; //! A variable to hold the weapon's clip size (How much ammo is in the clip). int currentClip; //! A variable to delineate the maximum value that can be held within a clip (currentClip). int maximumClip; //! A variable to hold the system path to the weapon's Mesh. io::path weaponModelMesh; //! A variable to hold the system path to the weapon's Texture. io::path weaponModelTexture; }; // Instantiation of the Weapon Struct's as discrete Objects. //! An instance of the Weapon struct for the Rifle weapon. Weapon Rifle; //! An instance of the Weapon struct for the Pistol weapon. Weapon Pistol; //! An instance of the Weapon struct for the Gattling weapon. Weapon Gatling; //! An instance of the Weapon struct for the Blunderbuss weapon. Weapon Blunderbuss; /** \brief A function to return the filepath of the selected weapon's mesh. * \param weaponSelected as an int. * \return filepath of the weapon's mesh as a std::string. */ io::path getWeaponMesh( int weaponSelected ); /** \brief A function to return the filepath of the selected weapon's texture. * \param weaponSelected as an int. * \return filepath of the weapon's mesh as a std::string. */ io::path getWeaponTexture( int weaponSelected ); /** \brief A function to return the name of the selected weapon. * \param weaponSelected as an int. * \return the weapon's name as a std::string. */ std::string getWeaponName( int weaponSelected ); }; #endif // PLAYER_H