NoEdge/Danbias
NoEdge
/
Danbias
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'GameLogic' of https://github.com/dean11/Danbias into GameLogic

This commit is contained in:
lindaandersson 2014-01-23 08:25:10 +01:00
parent f657a58a4f 6a888cb154
commit a591903d8f
26 changed files with 512 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
Code/Dokumentation/LevelLoader.uxf Normal file
View File

@ -0,0 +1,277 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<diagram program="umlet" version="12.0">
<zoom_level>8</zoom_level>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>552</x>
<y>320</y>
<w>584</w>
<h>368</h>
</coordinates>
<panel_attributes>LevelLoader</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>440</x>
<y>88</y>
<w>128</w>
<h>40</h>
</coordinates>
<panel_attributes>GameLogic
&lt;&lt;Erik&gt;&gt;</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>768</x>
<y>472</y>
<w>136</w>
<h>104</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>120;24;120;88;24;88</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>560</x>
<y>544</y>
<w>232</w>
<h>136</h>
</coordinates>
<panel_attributes>&lt;&lt;Interface&gt;&gt;
Parser
--
Functions:
vector&lt;struct&gt; Parse();
-
Privates:
enum headerType;
const int FileHeaderSize;
const int FileVersion;
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>624</x>
<y>208</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>LevelLoader
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>640</x>
<y>208</y>
<w>40</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>384</x>
<y>176</y>
<w>256</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-&gt;&gt;&gt;&gt;
m1=1..1
m2=1..1
&lt;Knows about</panel_attributes>
<additional_attributes>240;40;24;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Package</type>
<coordinates>
<x>248</x>
<y>320</y>
<w>248</w>
<h>160</h>
</coordinates>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>800</x>
<y>360</y>
<w>208</w>
<h>136</h>
</coordinates>
<panel_attributes>&lt;&lt;Interface&gt;&gt;
Loader
--
Functions:
wchar* LoadFile(string fileName);
Model* LoadModel(string modelName);
Model* LoadModel(int modelID);
-
Privates:</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>328</x>
<y>208</y>
<w>80</w>
<h>24</h>
</coordinates>
<panel_attributes>Defines</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>256</x>
<y>360</y>
<w>232</w>
<h>104</h>
</coordinates>
<panel_attributes>Defines.h
&lt;&lt;Header file&gt;&gt;
--
Enum ObjectType(static, dynamic, specials);
.
Struct static;
Struct dynamic;
Struct specials</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>680</x>
<y>176</y>
<w>152</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;136;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>816</x>
<y>192</y>
<w>128</w>
<h>40</h>
</coordinates>
<panel_attributes>Resource Loader
&lt;&lt;Dennis&gt;&gt;&lt;&lt;Singleton&gt;</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>928</x>
<y>560</y>
<w>200</w>
<h>120</h>
</coordinates>
<panel_attributes>Collection of functions
&lt;&lt;lots of functions&gt;&gt;
--
functions for creating the right structs</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>768</x>
<y>576</y>
<w>176</w>
<h>56</h>
</coordinates>
<panel_attributes>lt=-
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;160;40</additional_attributes>
</element>
<element>
<type>com.umlet.element.Class</type>
<coordinates>
<x>560</x>
<y>360</y>
<w>232</w>
<h>136</h>
</coordinates>
<panel_attributes>LevelLoader
&lt;&lt;API&gt;&gt;&lt;Interface&gt;&gt;
--
Functions:
vector&lt;struct&gt; LoadLevel(String fileName);
struct LoadLevelHeader(String fileName);
-
Privates:
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>344</x>
<y>208</y>
<w>40</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;.</panel_attributes>
<additional_attributes>24;24;24;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>840</x>
<y>208</y>
<w>88</w>
<h>168</h>
</coordinates>
<panel_attributes>lt=.
&lt;Uses</panel_attributes>
<additional_attributes>24;24;24;64;72;64;72;152</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>656</x>
<y>472</y>
<w>40</w>
<h>88</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes>
<additional_attributes>24;72;24;24</additional_attributes>
</element>
<element>
<type>com.umlet.element.Relation</type>
<coordinates>
<x>544</x>
<y>64</y>
<w>136</w>
<h>160</h>
</coordinates>
<panel_attributes>lt=lt=-&gt;&gt;&gt;&gt;
m1=1..1
m2=1..1
Uses&gt;</panel_attributes>
<additional_attributes>24;40;80;40;120;40;120;144</additional_attributes>
</element>
</diagram>

43
Code/Game/GameLogic/AttatchmentMassDriver.cpp
View File

@ -3,52 +3,38 @@
using namespace GameLogic;
struct AttatchmentMassDriver::PrivateData
{
PrivateData()
{
}
~PrivateData()
{
}
}myData;
AttatchmentMassDriver::AttatchmentMassDriver(void)
{
myData = new PrivateData();
this->owner = 0;
}
AttatchmentMassDriver::AttatchmentMassDriver(Player &owner)
{
myData = new PrivateData();
this->owner = &owner;
}
AttatchmentMassDriver::~AttatchmentMassDriver(void)
{
delete myData;
}
/********************************************************
* Uses the attatchment and will from here switch case the different WEAPON_FIRE's that are to be used
********************************************************/
void AttatchmentMassDriver::UseAttatchment(const GameLogic::WEAPON_FIRE &usage)
void AttatchmentMassDriver::UseAttatchment(const GameLogic::WEAPON_FIRE &usage, float dt)
{
//switch case to determin what functionallity to use in the attatchment
switch (usage)
{
case WEAPON_FIRE::WEAPON_USE_PRIMARY_PRESS:
ForcePush(usage);
ForcePush(usage,dt);
break;
case WEAPON_FIRE::WEAPON_USE_SECONDARY_PRESS:
ForcePull(usage);
ForcePull(usage,dt);
break;
}
@ -57,17 +43,28 @@ void AttatchmentMassDriver::UseAttatchment(const GameLogic::WEAPON_FIRE &usage)
/********************************************************
* Pushes objects in a cone in front of the weapon when fired
********************************************************/
void AttatchmentMassDriver::ForcePush(const GameLogic::WEAPON_FIRE &usage)
void AttatchmentMassDriver::ForcePush(const GameLogic::WEAPON_FIRE &usage, float dt)
{
//create coneRigidBody that will then collide with object and push them in the aimed direction
Oyster::Math::Float4 pushForce = Oyster::Math::Float4(this->owner->GetLookDir()) * (500 * dt);
Oyster::Math::Float4x4 aim = Oyster::Math3D::ViewMatrix_LookAtDirection(owner->GetLookDir(), owner->GetRigidBody()->GetGravityNormal(), owner->GetPosition());
Oyster::Math::Float4x4 hitSpace = Oyster::Math3D::ProjectionMatrix_Perspective(Oyster::Math::pi/4,1,1,20);
Oyster::Collision3D::Frustrum hitFrustum = Oyster::Collision3D::Frustrum(Oyster::Math3D::ViewProjectionMatrix(aim,hitSpace));
//Oyster::Physics::API::Instance().ApplyEffect(hitFrustum,ForcePushAction);
}
/********************************************************
* Pulls the player in the direction he is looking, used for fast movement(kinda like a jetpack)
********************************************************/
void AttatchmentMassDriver::ForcePull(const WEAPON_FIRE &usage)
void AttatchmentMassDriver::ForcePull(const WEAPON_FIRE &usage, float dt)
{
//Oyster::Physics::API::Instance().ApplyForceAt(owner->GetRigidBody(), owner->GetRigidBody()->GetCenter(), owner->GetLookDir() * 100);
Oyster::Physics::Struct::CustomBodyState state = this->owner->GetRigidBody()->GetState();
//do something with state
state.ApplyLinearImpulse(Oyster::Math::Float4(this->owner->GetLookDir()) * (500 * dt));
this->owner->GetRigidBody()->SetState(state);
}

13
Code/Game/GameLogic/AttatchmentMassDriver.h
View File

@ -15,30 +15,31 @@ namespace GameLogic
~AttatchmentMassDriver(void);
void UseAttatchment(const WEAPON_FIRE &usage);
void UseAttatchment(const WEAPON_FIRE &usage, float dt);
private:
/********************************************************
* Pushes objects and players in a cone in front of the player
* @param fireInput: allows switching on different functionality in this specific function
********************************************************/
void ForcePush(const WEAPON_FIRE &usage);
void ForcePush(const WEAPON_FIRE &usage, float dt);
/********************************************************
* Pulls the player forward, this is a movement tool
* @param fireInput: allows switching on different functionality in this specific function
********************************************************/
void ForcePull(const WEAPON_FIRE &usage);
void ForcePull(const WEAPON_FIRE &usage, float dt);
/********************************************************
* Sucks objects towards the player, the player can then pick up an object and throw it as a projectile
* @param fireInput: allows switching on different functionality in this specific function
********************************************************/
void ForceSuck(const WEAPON_FIRE &usage);
void ForceSuck(const WEAPON_FIRE &usage, float dt);
void ForcePushAction(Oyster::Physics::ICustomBody *obj);
private:
struct PrivateData;
PrivateData *myData;
};
}
#endif

79
Code/Game/GameLogic/CollisionManager.cpp
View File

@ -1,62 +1,65 @@
#include "CollisionManager.h"
#include "PhysicsAPI.h"
#include "Object.h"
#include "DynamicObject.h"
#include "Player.h"
#include "Level.h"
#include "AttatchmentMassDriver.h"
using namespace Oyster;
using namespace GameLogic;
void PlayerVBox(Player &player, DynamicObject &box);
void PlayerVBox(Player &player, DynamicObject &box, Oyster::Math::Float kineticEnergyLoss);
void PlayerVObject(Player &player, Object &obj, Oyster::Math::Float kineticEnergyLoss);
Physics::ICustomBody::SubscriptMessage CollisionManager::PlayerCollision(const Oyster::Physics::ICustomBody *rigidBodyPlayer, const Oyster::Physics::ICustomBody *obj)
//Physics::ICustomBody::SubscriptMessage
void Player::PlayerCollision(const Oyster::Physics::ICustomBody *rigidBodyPlayer, const Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
{
//Player *player = ((Player*)(rigidBodyPlayer->gameObjectRef));
//Object *realObj = (Object*)obj->gameObjectRef;
Player *player = ((Player*)(rigidBodyPlayer->GetCustomTag()));
Object *realObj = (Object*)obj->GetCustomTag();
//switch (realObj->GetType())
//{
//case OBJECT_TYPE::OBJECT_TYPE_BOX:
// PlayerVBox(*player,(*(DynamicObject*) realObj));
// break;
//case OBJECT_TYPE::OBJECT_TYPE_PLAYER:
//
// break;
//}
switch (realObj->GetType())
{
case OBJECT_H::OBJECT_TYPE_GENERIC:
PlayerVObject(*player,*realObj, kineticEnergyLoss);
//return Physics::ICustomBody::SubscriptMessage_none;
break;
return Physics::ICustomBody::SubscriptMessage_none;
case OBJECT_TYPE::OBJECT_TYPE_BOX:
PlayerVBox(*player,(*(DynamicObject*) realObj), kineticEnergyLoss);
//return Physics::ICustomBody::SubscriptMessage_none;
break;
case OBJECT_TYPE::OBJECT_TYPE_PLAYER:
//return Physics::ICustomBody::SubscriptMessage_none;
break;
}
void PlayerVBox(Player &player, DynamicObject &box)
//return Physics::ICustomBody::SubscriptMessage_none;
}
void PlayerVBox(Player &player, DynamicObject &box, Oyster::Math::Float kineticEnergyLoss)
{
//use kinetic energyloss of the collision in order too determin how much damage to take
//use as part of the damage algorithm
player.DamageLife(20);
}
Physics::ICustomBody::SubscriptMessage CollisionManager::BoxCollision(const Oyster::Physics::ICustomBody *rigidBodyBox, const Oyster::Physics::ICustomBody *obj)
void PlayerVObject(Player &player, Object &obj, Oyster::Math::Float kineticEnergyLoss)
{
if(rigidBodyBox == 0)
{
return Physics::ICustomBody::SubscriptMessage::SubscriptMessage_none;
}
//DynamicObject *box = (DynamicObject*)rigidBodyBox->gameObjectRef;
//Object *realObj = (Object*)obj->gameObjectRef;
//switch (realObj->GetType())
//{
//case OBJECT_TYPE::OBJECT_TYPE_BOX:
//
// break;
//case OBJECT_TYPE::OBJECT_TYPE_PLAYER:
// //PlayerVBox(*(Player*)realObj,*box);
// break;
//}
return Physics::ICustomBody::SubscriptMessage_none;
//Collision between a player and a general static or dynamic object
//use kinetic energyloss of the collision in order too determin how much damage to take
//use as part of the damage algorithm
player.DamageLife(20);
}
Oyster::Physics::ICustomBody::SubscriptMessage CollisionManager::LevelCollision(const Oyster::Physics::ICustomBody *rigidBodyLevel, const Oyster::Physics::ICustomBody *obj)
//Oyster::Physics::ICustomBody::SubscriptMessage
void Level::LevelCollision(const Oyster::Physics::ICustomBody *rigidBodyLevel, const Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
{
return Physics::ICustomBody::SubscriptMessage_ignore_collision_response;
//return Physics::ICustomBody::SubscriptMessage_ignore_collision_response;
}
void AttatchmentMassDriver::ForcePushAction(Oyster::Physics::ICustomBody *obj)
{
Oyster::Math::Float4 pushForce = Oyster::Math::Float4(this->owner->GetLookDir()) * (500);
((Object*)obj->GetCustomTag())->ApplyLinearImpulse(pushForce);
}

9
Code/Game/GameLogic/CollisionManager.h
View File

@ -10,14 +10,7 @@ namespace GameLogic
class CollisionManager
{
public:
//these are the main collision functions
//typedef SubscriptMessage (*EventAction_Collision)( const ICustomBody *proto, const ICustomBody *deuter );
static Oyster::Physics::ICustomBody::SubscriptMessage PlayerCollision(const Oyster::Physics::ICustomBody *rigidBodyPlayer, const Oyster::Physics::ICustomBody *obj);
static Oyster::Physics::ICustomBody::SubscriptMessage BoxCollision(const Oyster::Physics::ICustomBody *rigidBodyBox, const Oyster::Physics::ICustomBody *obj);
static Oyster::Physics::ICustomBody::SubscriptMessage LevelCollision(const Oyster::Physics::ICustomBody *rigidBodyLevel, const Oyster::Physics::ICustomBody *obj);
//these are the specific collision case functions
//void PlayerVBox(Player &player, DynamicObject &box);
//void BoxVBox(DynamicObject &box1, DynamicObject &box2);
//put general collision functions here that are not part of a specific object
};

1
Code/Game/GameLogic/GameLogicStates.h
View File

@ -25,6 +25,7 @@ namespace GameLogic
OBJECT_TYPE_PLAYER = 0,
OBJECT_TYPE_BOX = 1,
OBJECT_TYPE_WORLD = 2,
OBJECT_TYPE_GENERIC = 4,
OBJECT_TYPE_UNKNOWN = -1,
};

2
Code/Game/GameLogic/IAttatchment.h
View File

@ -19,7 +19,7 @@ namespace GameLogic
IAttatchment(void);
~IAttatchment(void);
virtual void UseAttatchment(const WEAPON_FIRE &usage) = 0;
virtual void UseAttatchment(const WEAPON_FIRE &usage, float dt) = 0;
private:

2
Code/Game/GameLogic/Level.cpp
View File

@ -25,7 +25,7 @@ void Level::InitiateLevel(float radius)
sbDesc.radius = 8; //radius;
sbDesc.mass = 10e12f;
//sbDesc.mass = 0; //10^16
sbDesc.subscription_onCollision = CollisionManager::LevelCollision;
sbDesc.subscription_onCollisionResponse = Level::LevelCollision;
ICustomBody* rigidBody = API::Instance().CreateRigidBody(sbDesc).Release();
API::Instance().AddObject(rigidBody);

8
Code/Game/GameLogic/Level.h
View File

@ -51,6 +51,14 @@ namespace GameLogic
********************************************************/
void RespawnPlayer(Player *player);
/********************************************************
* Collision function for level, this is to be sent to physics through the subscribe function with the rigidbody
* Will be called when the physics detect a collision
* @param rigidBodyLevel: physics object of the level
* @param obj: physics object for the object that collided with the level
********************************************************/
static void LevelCollision(const Oyster::Physics::ICustomBody *rigidBodyLevel, const Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss);
private:
TeamManager teamManager;
Utility::DynamicMemory::DynamicArray<Utility::DynamicMemory::SmartPointer<StaticObject>> staticObjects;

5
Code/Game/GameLogic/Object.cpp
View File

@ -49,6 +49,11 @@ Object::Object(void* collisionFunc, OBJECT_TYPE type)
this->type = type;
}
void Object::ApplyLinearImpulse(Oyster::Math::Float4 force)
{
setState.ApplyLinearImpulse(force);
}
Object::~Object(void)
{

1
Code/Game/GameLogic/Object.h
View File

@ -23,6 +23,7 @@ namespace GameLogic
OBJECT_TYPE GetType() const;
int GetID() const;
Oyster::Physics::ICustomBody* GetRigidBody();
void ApplyLinearImpulse(Oyster::Math::Float4 force);
void BeginFrame();
void EndFrame();

4
Code/Game/GameLogic/Player.cpp
View File

@ -8,7 +8,7 @@ using namespace GameLogic;
using namespace Oyster::Physics;
Player::Player()
:DynamicObject(CollisionManager::PlayerCollision, OBJECT_TYPE::OBJECT_TYPE_PLAYER)
:DynamicObject(Player::PlayerCollision, OBJECT_TYPE::OBJECT_TYPE_PLAYER)
{
weapon = new Weapon();
@ -81,7 +81,7 @@ void Player::MoveLeft()
void Player::UseWeapon(const WEAPON_FIRE &usage)
{
this->weapon->Use(usage);
this->weapon->Use(usage,gameInstance->GetFrameTime());
}
void Player::Respawn(Oyster::Math::Float3 spawnPoint)

13
Code/Game/GameLogic/Player.h
View File

@ -41,8 +41,18 @@ namespace GameLogic
********************************************************/
void Respawn(Oyster::Math::Float3 spawnPoint);
void Rotate(float x, float y);
/********************************************************
* Collision function for player, this is to be sent to physics through the subscribe function with the rigidbody
* Will be called when the physics detect a collision
* @param rigidBodyPlayer: physics object of the player
* @param obj: physics object for the object that collided with the player
********************************************************/
static void PlayerCollision(const Oyster::Physics::ICustomBody *rigidBodyPlayer, const Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss);
bool IsWalking();
bool IsJumping();
bool IsIdle();
@ -65,6 +75,9 @@ namespace GameLogic
PLAYER_STATE playerState;
Oyster::Math::Float4 lookDir;
bool hasTakenDamage;
float invincibleCooldown;
};
}
#endif

63
Code/Game/GameLogic/Weapon.cpp
View File

@ -1,14 +1,12 @@
#include "Weapon.h"
#include "AttatchmentSocket.h"
#include "AttatchmentMassDriver.h"
#include "DynamicArray.h"
using namespace GameLogic;
using namespace Utility::DynamicMemory;
struct Weapon::PrivateData
{
PrivateData()
Weapon::Weapon()
{
weaponState = WEAPON_STATE_IDLE;
selectedAttatchment = 0;
@ -17,44 +15,25 @@ struct Weapon::PrivateData
attatchmentSockets = 0;
}
~PrivateData()
{
}
WEAPON_STATE weaponState;
DynamicArray<SmartPointer<AttatchmentSocket>> attatchmentSockets;
int currentNrOfAttatchments;
SmartPointer<IAttatchment> selectedAttatchment;
int selectedSocketID;
}myData;
Weapon::Weapon()
{
myData = new PrivateData();
}
Weapon::Weapon(int MaxNrOfSockets)
{
myData = new PrivateData();
myData->attatchmentSockets.Resize(MaxNrOfSockets);
attatchmentSockets.Resize(MaxNrOfSockets);
}
Weapon::~Weapon(void)
{
delete myData;
}
/********************************************************
* Uses the weapon based on the input given and the current chosen attatchment
********************************************************/
void Weapon::Use(const WEAPON_FIRE &usage)
void Weapon::Use(const WEAPON_FIRE &usage, float dt)
{
if (myData->selectedAttatchment)
if (selectedAttatchment)
{
myData->selectedAttatchment->UseAttatchment(usage);
selectedAttatchment->UseAttatchment(usage, dt);
}
}
@ -68,24 +47,24 @@ void Weapon::Use(const WEAPON_FIRE &usage)
********************************************************/
bool Weapon::IsFireing()
{
return (myData->weaponState == WEAPON_STATE::WEAPON_STATE_FIRING);
return (weaponState == WEAPON_STATE::WEAPON_STATE_FIRING);
}
bool Weapon::IsIdle()
{
return (myData->weaponState == WEAPON_STATE::WEAPON_STATE_IDLE);
return (weaponState == WEAPON_STATE::WEAPON_STATE_IDLE);
}
bool Weapon::IsReloading()
{
return (myData->weaponState == WEAPON_STATE::WEAPON_STATE_RELOADING);
return (weaponState == WEAPON_STATE::WEAPON_STATE_RELOADING);
}
bool Weapon::IsValidSocket(int socketID)
{
if(socketID < (int)myData->attatchmentSockets.Size() && socketID >= 0)
if(socketID < (int)attatchmentSockets.Size() && socketID >= 0)
{
if (myData->attatchmentSockets[socketID]->GetAttatchment() != 0)
if (attatchmentSockets[socketID]->GetAttatchment() != 0)
{
return true;
}
@ -96,16 +75,16 @@ bool Weapon::IsValidSocket(int socketID)
int Weapon::GetCurrentSocketID()
{
return myData->selectedSocketID;
return selectedSocketID;
}
void Weapon::AddNewAttatchment(IAttatchment *attatchment, Player *owner)
{
if(myData->currentNrOfAttatchments < (int)myData->attatchmentSockets.Size())
if(currentNrOfAttatchments < (int)attatchmentSockets.Size())
{
myData->attatchmentSockets[myData->currentNrOfAttatchments]->SetAttatchment(attatchment);
myData->currentNrOfAttatchments++;
attatchmentSockets[currentNrOfAttatchments]->SetAttatchment(attatchment);
currentNrOfAttatchments++;
}
}
@ -113,7 +92,7 @@ void Weapon::SwitchAttatchment(IAttatchment *attatchment, int socketID, Player *
{
if (IsValidSocket(socketID))
{
myData->attatchmentSockets[socketID]->SetAttatchment(attatchment);
attatchmentSockets[socketID]->SetAttatchment(attatchment);
}
}
@ -121,7 +100,7 @@ void Weapon::RemoveAttatchment(int socketID)
{
if (IsValidSocket(socketID))
{
myData->attatchmentSockets[socketID]->RemoveAttatchment();
attatchmentSockets[socketID]->RemoveAttatchment();
}
}
@ -129,8 +108,8 @@ void Weapon::SelectAttatchment(int socketID)
{
if (IsValidSocket(socketID))
{
myData->selectedAttatchment = myData->attatchmentSockets[socketID]->GetAttatchment();
myData->selectedSocketID = socketID;
selectedAttatchment = attatchmentSockets[socketID]->GetAttatchment();
selectedSocketID = socketID;
}
}

14
Code/Game/GameLogic/Weapon.h
View File

@ -6,21 +6,20 @@
#include "GameLogicStates.h"
#include "IAttatchment.h"
#include "Player.h"
#include "AttatchmentSocket.h"
#include "DynamicArray.h"
namespace GameLogic
{
class Weapon
{
public:
Weapon(void);
Weapon(int nrOfAttatchmentSockets);
~Weapon(void);
void Use(const WEAPON_FIRE &fireInput);
void Use(const WEAPON_FIRE &usage, float dt);
void AddNewAttatchment(IAttatchment *attatchment, Player *owner);
void SwitchAttatchment(IAttatchment *attatchment, int socketID, Player *owner);
@ -36,8 +35,11 @@ namespace GameLogic
int GetCurrentSocketID();
private:
struct PrivateData;
PrivateData *myData;
WEAPON_STATE weaponState;
Utility::DynamicMemory::DynamicArray<AttatchmentSocket*> attatchmentSockets;
int currentNrOfAttatchments;
IAttatchment *selectedAttatchment;
int selectedSocketID;
};
}

2
Code/GamePhysics/Implementation/Octree.cpp
View File

@ -134,7 +134,7 @@ void Octree::Visit(const Oyster::Collision3D::ICollideable& collideable, Visitor
{
if(collideable.Intersects(this->leafData[i].container))
{
hitAction(*this, i);
hitAction( this->GetCustomBody(i) );
}
}
}

2
Code/GamePhysics/Implementation/Octree.h
View File

@ -18,7 +18,7 @@ namespace Oyster
static const unsigned int invalid_ref;
typedef void(*VisitorAction)(Octree&, unsigned int, unsigned int);
typedef void(*VisitorActionCollideable)(Octree&, unsigned int);
typedef void(*VisitorActionCollideable)(ICustomBody*);
struct Data
{

12
Code/GamePhysics/Implementation/PhysicsAPI_Impl.cpp
View File

@ -94,9 +94,14 @@ namespace
// proto->Predict( forwardedDeltaPos, forwardedDeltaAxis, bounceLinearImpulse, bounceAngularImpulse, API_instance.GetFrameTimeLength() );
// }
// protoState.ApplyForwarding( forwardedDeltaPos, forwardedDeltaAxis );
protoState.ApplyImpulse( bounce, worldPointOfContact, normal );
proto->SetState( protoState );
proto->CallSubscription_CollisionResponse( deuter, protoState.GetLinearMomentum().GetMagnitude()/(protoState.GetMass() + protoState.GetLinearMomentum().GetMagnitude()));
}
break;
}
@ -270,7 +275,7 @@ void API_Impl::RemoveGravity( const API::Gravity &g )
}
}
void API_Impl::ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(Octree&, unsigned int) )
void API_Impl::ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(ICustomBody*) )
{
this->worldScene.Visit(collideable, hitAction);
}
@ -383,6 +388,11 @@ namespace Oyster { namespace Physics
return ::Oyster::Physics::ICustomBody::SubscriptMessage_none;
}
void EventAction_CollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss )
{ /* Do nothing except returning business as usual. */
}
void EventAction_Move( const ::Oyster::Physics::ICustomBody *object )
{ /* Do nothing. */ }
}

3
Code/GamePhysics/Implementation/PhysicsAPI_Impl.h
View File

@ -35,7 +35,7 @@ namespace Oyster
void AddGravity( const API::Gravity &g );
void RemoveGravity( const API::Gravity &g );
void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(Octree&, unsigned int) );
void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(ICustomBody*) );
//void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF );
@ -62,6 +62,7 @@ namespace Oyster
{
void EventAction_Destruction( ::Utility::DynamicMemory::UniquePointer<::Oyster::Physics::ICustomBody> proto );
::Oyster::Physics::ICustomBody::SubscriptMessage EventAction_Collision( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter );
void EventAction_CollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
void EventAction_Move( const ::Oyster::Physics::ICustomBody *object );
}
}

27
Code/GamePhysics/Implementation/SimpleRigidBody.cpp
View File

@ -47,6 +47,7 @@ SimpleRigidBody::SimpleRigidBody()
this->rigid.SetMass_KeepMomentum( 16.0f );
this->gravityNormal = Float3::null;
this->onCollision = Default::EventAction_Collision;
this->onCollisionResponse = Default::EventAction_CollisionResponse;
this->onMovement = Default::EventAction_Move;
this->scene = nullptr;
this->customTag = nullptr;
@ -74,6 +75,15 @@ SimpleRigidBody::SimpleRigidBody( const API::SimpleBodyDescription &desc )
this->onCollision = Default::EventAction_Collision;
}
if( desc.subscription_onCollisionResponse )
{
this->onCollisionResponse = desc.subscription_onCollisionResponse;
}
else
{
this->onCollisionResponse = Default::EventAction_CollisionResponse;
}
if( desc.subscription_onMovement )
{
this->onMovement= desc.subscription_onMovement;
@ -158,6 +168,11 @@ ICustomBody::SubscriptMessage SimpleRigidBody::CallSubscription_Collision( const
return this->onCollision( this, deuter );
}
void SimpleRigidBody::CallSubscription_CollisionResponse( const ICustomBody *deuter, Float kineticEnergyLoss )
{
return this->onCollisionResponse( this, deuter, kineticEnergyLoss );
}
void SimpleRigidBody::CallSubscription_Move()
{
this->onMovement( this );
@ -315,6 +330,18 @@ void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_Collision functi
}
}
void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_CollisionResponse functionPointer )
{
if( functionPointer )
{
this->onCollisionResponse = functionPointer;
}
else
{
this->onCollisionResponse = Default::EventAction_CollisionResponse;
}
}
void SimpleRigidBody::SetSubscription( ICustomBody::EventAction_Move functionPointer )
{
if( functionPointer )

3
Code/GamePhysics/Implementation/SimpleRigidBody.h
View File

@ -22,6 +22,7 @@ namespace Oyster { namespace Physics
//::Oyster::Math::Float3 GetRigidLinearVelocity() const;
SubscriptMessage CallSubscription_Collision( const ICustomBody *deuter );
void CallSubscription_CollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
void CallSubscription_Move();
bool IsAffectedByGravity() const;
@ -44,6 +45,7 @@ namespace Oyster { namespace Physics
void SetScene( void *scene );
void SetSubscription( EventAction_Collision functionPointer );
void SetSubscription( EventAction_CollisionResponse functionPointer );
void SetSubscription( EventAction_Move functionPointer );
void SetGravity( bool ignore);
@ -64,6 +66,7 @@ namespace Oyster { namespace Physics
::Oyster::Math::Float4 deltaPos, deltaAxis;
::Oyster::Math::Float3 gravityNormal;
EventAction_Collision onCollision;
EventAction_CollisionResponse onCollisionResponse;
EventAction_Move onMovement;
Octree *scene;
void *customTag;

28
Code/GamePhysics/Implementation/SphericalRigidBody.cpp
View File

@ -14,6 +14,7 @@ SphericalRigidBody::SphericalRigidBody()
this->rigid.SetMass_KeepMomentum( 10.0f );
this->gravityNormal = Float3::null;
this->onCollision = Default::EventAction_Collision;
this->onCollisionResponse = Default::EventAction_CollisionResponse;
this->onMovement = Default::EventAction_Move;
this->scene = nullptr;
this->customTag = nullptr;
@ -42,6 +43,15 @@ SphericalRigidBody::SphericalRigidBody( const API::SphericalBodyDescription &des
this->onCollision = Default::EventAction_Collision;
}
if( desc.subscription_onCollisionResponse )
{
this->onCollisionResponse = desc.subscription_onCollisionResponse;
}
else
{
this->onCollisionResponse = Default::EventAction_CollisionResponse;
}
if( desc.subscription_onMovement )
{
this->onMovement= desc.subscription_onMovement;
@ -123,6 +133,12 @@ ICustomBody::SubscriptMessage SphericalRigidBody::CallSubscription_Collision( co
return this->onCollision( this, deuter );
}
void SphericalRigidBody::CallSubscription_CollisionResponse( const ICustomBody *deuter, Float kineticEnergyLoss )
{
this->onCollisionResponse( this, deuter, kineticEnergyLoss);
}
void SphericalRigidBody::CallSubscription_Move()
{
this->onMovement( this );
@ -234,6 +250,18 @@ void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_Collision fun
}
}
void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_CollisionResponse functionPointer )
{
if( functionPointer )
{
this->onCollisionResponse = functionPointer;
}
else
{
this->onCollisionResponse = Default::EventAction_CollisionResponse;
}
}
void SphericalRigidBody::SetSubscription( ICustomBody::EventAction_Move functionPointer )
{
if( functionPointer )

3
Code/GamePhysics/Implementation/SphericalRigidBody.h
View File

@ -23,6 +23,7 @@ namespace Oyster { namespace Physics
//::Oyster::Math::Float3 GetRigidLinearVelocity() const;
SubscriptMessage CallSubscription_Collision( const ICustomBody *deuter );
void CallSubscription_CollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss );
void CallSubscription_Move();
bool IsAffectedByGravity() const;
@ -45,6 +46,7 @@ namespace Oyster { namespace Physics
void SetScene( void *scene );
void SetSubscription( EventAction_Collision functionPointer );
void SetSubscription( EventAction_CollisionResponse functionPointer );
void SetSubscription( EventAction_Move functionPointer );
void SetGravity( bool ignore);
@ -65,6 +67,7 @@ namespace Oyster { namespace Physics
::Oyster::Math::Float4 deltaPos, deltaAxis;
::Oyster::Math::Float3 gravityNormal;
EventAction_Collision onCollision;
EventAction_CollisionResponse onCollisionResponse;
EventAction_Move onMovement;
Octree *scene;
void *customTag;

21
Code/GamePhysics/PhysicsAPI.h
View File

@ -16,7 +16,6 @@ namespace Oyster
{
class API;
class ICustomBody;
class Octree;
namespace Struct
{
@ -137,7 +136,12 @@ namespace Oyster
********************************************************/
virtual void RemoveGravity( const API::Gravity &g ) = 0;
virtual void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(Octree&, unsigned int) ) = 0;
/********************************************************
* Applies an effect to objects that collide with the set volume.
* @param collideable: An ICollideable that defines the volume of the effect.
* @param hitAction: A function that contains the effect.
********************************************************/
virtual void ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(ICustomBody*) ) = 0;
///********************************************************
// * Apply force on an object.
@ -234,6 +238,7 @@ namespace Oyster
enum SubscriptMessage
{
SubscriptMessage_none,
SubscriptMessage_kineticLoss,
SubscriptMessage_ignore_collision_response
};
@ -257,6 +262,11 @@ namespace Oyster
********************************************************/
virtual SubscriptMessage CallSubscription_Collision( const ICustomBody *deuter ) = 0;
/********************************************************
* @todo TODO: need doc
********************************************************/
virtual void CallSubscription_CollisionResponse( const ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss ) = 0;
/********************************************************
* @todo TODO: need doc
********************************************************/
@ -387,6 +397,13 @@ namespace Oyster
********************************************************/
virtual void SetSubscription( EventAction_Collision functionPointer ) = 0;
/********************************************************
* Sets the function that will be called by the engine
* whenever a collision has finished.
* @param functionPointer: If NULL, an empty default function will be set.
********************************************************/
virtual void SetSubscription( EventAction_CollisionResponse functionPointer ) = 0;
/********************************************************
* Sets the function that will be called by the engine
* whenever an object have moved.

2
Code/GamePhysics/PhysicsStructs-Impl.h
View File

@ -21,6 +21,7 @@ namespace Oyster
this->frictionCoeff_Static = 0.5f;
this->inertiaTensor = ::Oyster::Math::Float4x4::identity;
this->subscription_onCollision = NULL;
this->subscription_onCollisionResponse = NULL;
this->subscription_onMovement = NULL;
this->ignoreGravity = false;
}
@ -35,6 +36,7 @@ namespace Oyster
this->frictionCoeff_Dynamic = 0.5f;
this->frictionCoeff_Static = 0.5f;
this->subscription_onCollision = NULL;
this->subscription_onCollisionResponse = NULL;
this->subscription_onMovement = NULL;
this->ignoreGravity = false;
}

2
Code/GamePhysics/PhysicsStructs.h
View File

@ -19,6 +19,7 @@ namespace Oyster { namespace Physics
::Oyster::Math::Float frictionCoeff_Dynamic;
::Oyster::Math::Float4x4 inertiaTensor;
::Oyster::Physics::ICustomBody::EventAction_Collision subscription_onCollision;
::Oyster::Physics::ICustomBody::EventAction_CollisionResponse subscription_onCollisionResponse;
::Oyster::Physics::ICustomBody::EventAction_Move subscription_onMovement;
bool ignoreGravity;
@ -35,6 +36,7 @@ namespace Oyster { namespace Physics
::Oyster::Math::Float frictionCoeff_Static;
::Oyster::Math::Float frictionCoeff_Dynamic;
::Oyster::Physics::ICustomBody::EventAction_Collision subscription_onCollision;
::Oyster::Physics::ICustomBody::EventAction_CollisionResponse subscription_onCollisionResponse;
::Oyster::Physics::ICustomBody::EventAction_Move subscription_onMovement;
bool ignoreGravity;