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

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

This commit is contained in:
dean11 2014-02-24 11:05:30 +01:00
parent 17d5991545 7bb67b6a85
commit 7f067b0010
23 changed files with 277 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Code/Game/GameClient/GameClientState/C_obj/C_DynamicObj.cpp
View File

@ -3,6 +3,7 @@
using namespace DanBias::Client;
C_DynamicObj::C_DynamicObj(void)
:C_Object()
{
}

1
Code/Game/GameClient/GameClientState/C_obj/C_StaticObj.cpp
View File

@ -3,6 +3,7 @@
using namespace DanBias::Client;
C_StaticObj::C_StaticObj(void)
:C_Object()
{
}

15
Code/Game/GameClient/GameClientState/GameState.cpp
View File

@ -218,13 +218,16 @@ bool GameState::Render()
playerObject = this->privData->players.begin();
for( ; playerObject != this->privData->players.end(); ++playerObject )
{
if( playerObject->second->getBRtype() == RB_Type_Cube)
if(playerObject->second)
{
Oyster::Graphics::API::RenderDebugCube( playerObject->second->getRBWorld());
}
if( playerObject->second->getBRtype() == RB_Type_Sphere)
{
Oyster::Graphics::API::RenderDebugSphere( playerObject->second->getRBWorld());
if( playerObject->second->getBRtype() == RB_Type_Cube)
{
Oyster::Graphics::API::RenderDebugCube( playerObject->second->getRBWorld());
}
if( playerObject->second->getBRtype() == RB_Type_Sphere)
{
Oyster::Graphics::API::RenderDebugSphere( playerObject->second->getRBWorld());
}
}
}

2
Code/Game/GameClient/GameClientState/GamingUI.cpp
View File

@ -33,7 +33,7 @@ bool GamingUI::Init()
// z value should be between 0.5 - 0.9 so that it will be behind other states
// add textures and text
this->plane = new Plane_UI(L"box_tex.png", Float3(0.5f, 0.0f, 0.5f), Float2(0.3f, 0.1f));
this->text = new Text_UI(L"hej", Float3(0.5f,0.0f,0.1f), Float2(0.1f,0.1f));
this->text = new Text_UI(L"hej", Float3(0.3f,0.0f,0.1f), Float2(0.1f,0.1f));
return true;
}

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

@ -56,19 +56,14 @@ void AttatchmentMassDriver::Update(float dt)
//update position of heldObject if there is an object being held
if(hasObject)
{
//Oyster::Physics::ICustomBody::State state;
//state = heldObject->GetState();
Oyster::Math::Float3 ownerPos = owner->GetPosition();
Oyster::Physics::ICustomBody::State ownerState = owner->GetRigidBody()->GetState();
Oyster::Math::Float3 up = -ownerState.GetOrientation().v[2];
up *= -0.3f;
Oyster::Math::Float3 pos = ownerPos + (owner->GetLookDir().GetNormalized()*5);
//state.centerPos = pos;
Oyster::Math::Float3 pos = ownerPos + (owner->GetLookDir().GetNormalized()*2);
heldObject->SetPosition(pos);
heldObject->SetLinearVelocity(Oyster::Math::Float3::null);
//heldObject->SetState(state);
}
}
@ -149,7 +144,7 @@ void AttatchmentMassDriver::ForcePull(const WEAPON_FIRE &usage, float dt)
void AttatchmentMassDriver::PickUpObject(const WEAPON_FIRE &usage, float dt)
{
Oyster::Math::Float3 pos = owner->GetPosition() + owner->GetLookDir().GetNormalized()*5;
Oyster::Math::Float3 pos = owner->GetPosition() + owner->GetLookDir().GetNormalized()*2;
Oyster::Collision3D::Sphere *hitSphere = new Oyster::Collision3D::Sphere(pos,10);
Oyster::Physics::API::Instance().ApplyEffect(hitSphere,this,AttemptPickUp);

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

@ -108,13 +108,31 @@ using namespace GameLogic;
obj.SetPosition(target);
}
void ExplosiveCrate::ExplosiveCrateCollision(Oyster::Physics::ICustomBody *rigidBodyCrate, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
void ExplosiveCrate::ExplosiveCrateCollision(Oyster::Physics::ICustomBody *objA, Oyster::Physics::ICustomBody *objB, Oyster::Math::Float kineticEnergyLoss)
{
int forceThreashHold = 200000; //how much force for the box to explode of the impact
Object *realObj = (Object*)obj->GetCustomTag(); //needs to be changed?
Object *realObjA = ((Object*)(objA->GetCustomTag()));
Object *realObjB = (Object*)objB->GetCustomTag(); //needs to be changed?
ExplosiveCrate* crate;
switch (realObj->GetObjectType())
if(!realObjA)
return;
if(!realObjB)
return;
//check who is player and who is the object
if(realObjA->GetObjectType() == ObjectSpecialType::ObjectSpecialType_RedExplosiveBox)
{
crate = (ExplosiveCrate*)realObjA;
}
else
{
crate = (ExplosiveCrate*)realObjB;
realObjB = realObjA;
}
switch (realObjB->GetObjectType())
{
case ObjectSpecialType::ObjectSpecialType_Generic:
break;
@ -122,29 +140,15 @@ using namespace GameLogic;
break;
case ObjectSpecialType::ObjectSpecialType_Player:
ExplosiveCrate* crate = ((ExplosiveCrate*)rigidBodyCrate->GetCustomTag());
Oyster::Math::Float3 pos = rigidBodyCrate->GetState().centerPos;
if(crate->hasExploaded) return;
Oyster::Math::Float3 pos = crate->GetRigidBody()->GetState().centerPos;
Oyster::Collision3D::Sphere *hitSphere = new Oyster::Collision3D::Sphere(pos,crate->ExplosionRadius);
Oyster::Physics::API::Instance().ApplyEffect(hitSphere,crate,Explode);
crate->hasExploaded = true;
delete hitSphere;
break;
}
/*if(kineticEnergyLoss > forceThreashHold)
{
ExplosiveCrate* crate = ((ExplosiveCrate*)rigidBodyCrate->GetCustomTag());
Oyster::Math::Float3 pos = rigidBodyCrate->GetState().centerPos;
Oyster::Collision3D::Sphere *hitSphere = new Oyster::Collision3D::Sphere(pos,crate->ExplosionRadius);
Oyster::Physics::API::Instance().ApplyEffect(hitSphere,crate,Explode);
delete hitSphere;
}*/
}
void ExplosiveCrate::Explode(Oyster::Physics::ICustomBody *obj, void* args)
@ -155,16 +159,17 @@ using namespace GameLogic;
Oyster::Math::Float3 explosionCenterPos = ExplosionSource->GetPosition();
Oyster::Math::Float3 hitObjectPos = obj->GetState().centerPos;
Oyster::Math::Float3 force = (((hitObjectPos- explosionCenterPos).GetNormalized()) * ExplosionSource->pushForceMagnitude);
if(realObj->GetObjectType() == ObjectSpecialType::ObjectSpecialType_Player)
{
Player *hitPlayer = (Player*)realObj;
//hitPlayer->DamageLife(ExplosionSource->getExtraDamageOnCollision());
hitPlayer->DamageLife(ExplosionSource->extraDamageOnCollision);
//hitPlayer->GetRigidBody()->ApplyImpulse(force);
//do shredding damage
}
realObj->GetRigidBody()->ApplyImpulse(force);
}
@ -181,11 +186,11 @@ using namespace GameLogic;
Oyster::Math::Float angularFactor = deltaPos.GetNormalized().Dot( (objPrevVel - playerPrevVel).GetNormalized());
Oyster::Math::Float impactPower = deltaSpeed * angularFactor;
Oyster::Math::Float damageFactor = 0.1f;
Oyster::Math::Float damageFactor = 0.01f;
int damageDone = 0;
int forceThreashHold = 100; //FIX: balance this
int forceThreashHold = 30; //FIX: balance this
if(impactPower > forceThreashHold) //should only take damage if the force is high enough
{
@ -198,7 +203,7 @@ using namespace GameLogic;
damageDone = (impactPower * obj.GetRigidBody()->GetState().mass)* damageFactor;
}
//player.DamageLife(damageDone);
player.DamageLife(damageDone);
}
}

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

@ -7,6 +7,7 @@ ExplosiveCrate::ExplosiveCrate(void)
{
this->pushForceMagnitude = 0;
this->ExplosionRadius = 0;
this->hasExploaded = false;
}
ExplosiveCrate::ExplosiveCrate(Oyster::Physics::ICustomBody *rigidBody,ObjectSpecialType type, int objectID,Oyster::Math::Float extraDamageOnCollision, Oyster::Math::Float pushForceMagnitude, Oyster::Math::Float ExplosionRadius)
@ -15,6 +16,7 @@ ExplosiveCrate::ExplosiveCrate(Oyster::Physics::ICustomBody *rigidBody,ObjectSpe
this->extraDamageOnCollision = extraDamageOnCollision;
this->pushForceMagnitude = pushForceMagnitude;
this->ExplosionRadius = ExplosionRadius;
this->hasExploaded = false;
}
ExplosiveCrate::~ExplosiveCrate(void)

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

@ -18,6 +18,7 @@ namespace GameLogic
private:
Oyster::Math::Float pushForceMagnitude;
Oyster::Math::Float ExplosionRadius;
bool hasExploaded;
};

16
Code/Game/GameLogic/Game.cpp
View File

@ -43,6 +43,9 @@ Game::Game(void)
: initiated(false)
, onMoveFnc(0)
, onDisableFnc(0)
, onDamageTakenFnc(0)
, onRespawnFnc(0)
, onDeadFnc(0)
, frameTime(1.0f/120.0f)
{}
@ -156,7 +159,18 @@ void Game::SetSubscription(GameEvent::ObjectMovedFunction functionPointer)
void Game::SetSubscription(GameEvent::ObjectDisabledFunction functionPointer)
{
this->onDisableFnc = functionPointer;
}
void Game::SetHpSubscription(GameEvent::ObjectHpFunction functionPointer)
{
this->onDamageTakenFnc = functionPointer;
}
void Game::SetRespawnSubscription(GameEvent::ObjectRespawnedFunction functionPointer)
{
this->onRespawnFnc = functionPointer;
}
void Game::SetDeadSubscription(GameEvent::ObjectDeadFunction functionPointer)
{
this->onDeadFnc = functionPointer;
}
bool Game::Initiate()

12
Code/Game/GameLogic/Game.h
View File

@ -80,6 +80,10 @@ namespace GameLogic
void SetFrameTimeLength( float seconds ) override;
void SetSubscription(GameEvent::ObjectMovedFunction functionPointer) override;
void SetSubscription(GameEvent::ObjectDisabledFunction functionPointer) override;
void SetHpSubscription(GameEvent::ObjectHpFunction functionPointer) override;
void SetRespawnSubscription(GameEvent::ObjectRespawnedFunction functionPointer) override;
void SetDeadSubscription(GameEvent::ObjectDeadFunction functionPointer) override;
bool Initiate() override;
float GetFrameTime() const;
@ -91,9 +95,11 @@ namespace GameLogic
LevelData* level;
float frameTime;
bool initiated;
GameEvent::ObjectDisabledFunction onDisableFnc;
GameEvent::ObjectMovedFunction onMoveFnc;
GameEvent::ObjectDisabledFunction onDisableFnc;
GameEvent::ObjectMovedFunction onMoveFnc;
GameEvent::ObjectHpFunction onDamageTakenFnc;
GameEvent::ObjectRespawnedFunction onRespawnFnc;
GameEvent::ObjectDeadFunction onDeadFnc;
};
}

6
Code/Game/GameLogic/GameAPI.h
View File

@ -27,6 +27,9 @@ namespace GameLogic
{
typedef void(*ObjectMovedFunction)(IObjectData* object); // Callback method that recieves and object
typedef void(*ObjectDisabledFunction)(IObjectData* object, float seconds); // Callback method that recieves and object
typedef void(*ObjectHpFunction)(IObjectData* object, float hp); // Callback method that sends obj HP
typedef void(*ObjectRespawnedFunction)(IObjectData* object, Oyster::Math::Float3 spawnPos ); // Callback method that sends spawnPos
typedef void(*ObjectDeadFunction)(IObjectData* object, float seconds); // Callback method that sends death timer
//etc...
};
@ -178,6 +181,9 @@ namespace GameLogic
* @param
*/
virtual void SetSubscription(GameEvent::ObjectDisabledFunction functionPointer) = 0;
virtual void SetHpSubscription(GameEvent::ObjectHpFunction functionPointer) = 0;
virtual void SetRespawnSubscription(GameEvent::ObjectRespawnedFunction functionPointer) = 0;
virtual void SetDeadSubscription(GameEvent::ObjectDeadFunction functionPointer) = 0;
};
}

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

@ -69,9 +69,9 @@ Object* Level::CreateGameObj(ObjectHeader* obj, ICustomBody* rigidBody)
break;
case ObjectSpecialType_RedExplosiveBox:
{
Oyster::Math::Float dmg = 50;
Oyster::Math::Float force = 50;
Oyster::Math::Float radie = 50;
Oyster::Math::Float dmg = 90;
Oyster::Math::Float force = 500;
Oyster::Math::Float radie = 3;
gameObj = new ExplosiveCrate(rigidBody, (ObjectSpecialType)obj->specialTypeID, objID++, dmg, force, radie);
}
break;
@ -422,5 +422,5 @@ void Level::PhysicsOnMoveLevel(const ICustomBody *object)
// function call from physics update when object was moved
Object* temp = (Object*)object->GetCustomTag();
((Game*)&Game::Instance())->onMoveFnc(temp);
}

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

@ -66,6 +66,7 @@ namespace GameLogic
int getNrOfDynamicObj();
Object* GetObj( int ID ) const;
static void PhysicsOnMoveLevel(const Oyster::Physics::ICustomBody *object);

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

@ -29,6 +29,8 @@ Player::Player(Oyster::Physics::ICustomBody *rigidBody, void (*EventOnCollision)
key_strafeLeft = 0;
key_jump = 0;
invincibleCooldown = 0;
this->deathTimeLeft = 0;
this->deathTime = 5;
this->previousPosition = Oyster::Math::Float3(0,0,0);
@ -54,7 +56,8 @@ Player::Player(Oyster::Physics::ICustomBody *rigidBody, Oyster::Physics::ICustom
key_strafeLeft = 0;
key_jump = 0;
invincibleCooldown = 0;
this->deathTimeLeft = 0;
this->deathTime = 5;
this->previousPosition = Oyster::Math::Float3(0,0,0);
this->moveDir = Oyster::Math::Float3(0,0,0);
this->moveSpeed = 20;
@ -74,137 +77,142 @@ Player::~Player(void)
void Player::BeginFrame()
{
weapon->Update(0.002f);
//Object::BeginFrame();
if( this->playerState != PLAYER_STATE_DEAD)
{
weapon->Update(0.002f);
Oyster::Math::Float maxSpeed = 30;
Oyster::Math::Float maxSpeed = 30;
// Rotate player accordingly
this->rigidBody->SetUp(this->rigidBody->GetState().centerPos.GetNormalized());
Oyster::Math::Quaternion firstUp = this->rigidBody->GetState().quaternion;
this->rigidBody->SetRotationAsAngularAxis(Oyster::Math3D::Float4(this->rigidBody->GetState().centerPos.GetNormalized(), this->rotationUp));
Oyster::Math::Quaternion secondTurn = this->rigidBody->GetState().quaternion;
// Rotate player accordingly
this->rigidBody->SetUp(this->rigidBody->GetState().centerPos.GetNormalized());
Oyster::Math::Quaternion firstUp = this->rigidBody->GetState().quaternion;
this->rigidBody->SetRotationAsAngularAxis(Oyster::Math3D::Float4(this->rigidBody->GetState().centerPos.GetNormalized(), this->rotationUp));
Oyster::Math::Quaternion secondTurn = this->rigidBody->GetState().quaternion;
this->rigidBody->SetRotation(secondTurn*firstUp);
this->rigidBody->SetRotation(secondTurn*firstUp);
// Direction data
Oyster::Math::Float4x4 xform;
xform = this->rigidBody->GetState().GetOrientation();
// Direction data
Oyster::Math::Float4x4 xform;
xform = this->rigidBody->GetState().GetOrientation();
Oyster::Math::Float3 forwardDir = xform.v[2];
Oyster::Math::Float3 upDir = xform.v[1];
Oyster::Math::Float3 rightDir = xform.v[0];
forwardDir.Normalize();
upDir.Normalize();
rightDir.Normalize();
Oyster::Math::Float3 forwardDir = xform.v[2];
Oyster::Math::Float3 upDir = xform.v[1];
Oyster::Math::Float3 rightDir = xform.v[0];
forwardDir.Normalize();
upDir.Normalize();
rightDir.Normalize();
// Previous velocities data
Oyster::Math::Float3 linearVelocity = this->rigidBody->GetLinearVelocity();
Oyster::Math::Float3 forwardVelocity = linearVelocity*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z));
Oyster::Math::Float forwardSpeed = (linearVelocity*forwardDir).GetLength();
Oyster::Math::Float3 rightVelocity = linearVelocity*Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z));
Oyster::Math::Float rightSpeed = (linearVelocity*rightDir).GetLength();
Oyster::Math::Float3 upVelocity = linearVelocity*Oyster::Math::Float3(fabs(upDir.x), fabs(upDir.y), fabs(upDir.z));
// Previous velocities data
Oyster::Math::Float3 linearVelocity = this->rigidBody->GetLinearVelocity();
Oyster::Math::Float3 forwardVelocity = linearVelocity*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z));
Oyster::Math::Float forwardSpeed = (linearVelocity*forwardDir).GetLength();
Oyster::Math::Float3 rightVelocity = linearVelocity*Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z));
Oyster::Math::Float rightSpeed = (linearVelocity*rightDir).GetLength();
Oyster::Math::Float3 upVelocity = linearVelocity*Oyster::Math::Float3(fabs(upDir.x), fabs(upDir.y), fabs(upDir.z));
// Walking data
Oyster::Math::Float3 walkDirection = Oyster::Math::Float3(0.0, 0.0, 0.0);
Oyster::Math::Float walkSpeed = this->moveSpeed*0.2f;
// Walking data
Oyster::Math::Float3 walkDirection = Oyster::Math::Float3(0.0, 0.0, 0.0);
Oyster::Math::Float walkSpeed = this->moveSpeed*0.2f;
// Check for input
if(key_forward > 0.001)
{
key_forward -= gameInstance->GetFrameTime();
walkDirection += forwardDir;
}
if(key_backward > 0.001)
{
key_backward -= gameInstance->GetFrameTime();
walkDirection -= forwardDir;
}
if(key_strafeRight > 0.001)
{
key_strafeRight -= gameInstance->GetFrameTime();
walkDirection += rightDir;
}
if(key_strafeLeft > 0.001)
{
key_strafeLeft -= gameInstance->GetFrameTime();
walkDirection -= rightDir;
}
// Dampen velocity if certain keys are not pressed
if(key_jump <= 0.001 && this->rigidBody->GetLambda() < 0.9f)
{
if(key_forward <= 0.001 && key_backward <= 0.001)
// Check for input
if(key_forward > 0.001)
{
forwardVelocity *= Oyster::Math::Float3(0.2f*fabs(forwardDir.x), 0.2f*fabs(forwardDir.y), 0.2f*fabs(forwardDir.z));
key_forward -= gameInstance->GetFrameTime();
walkDirection += forwardDir;
}
if(key_strafeRight <= 0.001 && key_strafeLeft <= 0.001)
if(key_backward > 0.001)
{
rightVelocity *= Oyster::Math::Float3(0.2f*fabs(rightDir.x), 0.2f*fabs(rightDir.y), 0.2f*fabs(rightDir.z));
key_backward -= gameInstance->GetFrameTime();
walkDirection -= forwardDir;
}
}
// Walk if walkdirection is something
if(walkDirection != Oyster::Math::Float3::null)
{
walkDirection.Normalize();
// If on the ground, accelerate normally
if(this->rigidBody->GetLambda() < 0.9f)
if(key_strafeRight > 0.001)
{
if(forwardSpeed < maxSpeed)
key_strafeRight -= gameInstance->GetFrameTime();
walkDirection += rightDir;
}
if(key_strafeLeft > 0.001)
{
key_strafeLeft -= gameInstance->GetFrameTime();
walkDirection -= rightDir;
}
// Dampen velocity if certain keys are not pressed
if(key_jump <= 0.001 && this->rigidBody->GetLambda() < 0.9f)
{
if(key_forward <= 0.001 && key_backward <= 0.001)
{
forwardVelocity += walkDirection*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z)) * walkSpeed;
forwardVelocity *= Oyster::Math::Float3(0.2f*fabs(forwardDir.x), 0.2f*fabs(forwardDir.y), 0.2f*fabs(forwardDir.z));
}
if(rightSpeed < maxSpeed)
if(key_strafeRight <= 0.001 && key_strafeLeft <= 0.001)
{
rightVelocity += walkDirection*Oyster::Math::Float3(fabs(rightDir.x), abs(rightDir.y), fabs(rightDir.z)) * walkSpeed;
rightVelocity *= Oyster::Math::Float3(0.2f*fabs(rightDir.x), 0.2f*fabs(rightDir.y), 0.2f*fabs(rightDir.z));
}
}
// If in the air, accelerate slower
if(this->rigidBody->GetLambda() >= 0.9f)
// Walk if walkdirection is something
if(walkDirection != Oyster::Math::Float3::null)
{
if(forwardSpeed < maxSpeed)
walkDirection.Normalize();
// If on the ground, accelerate normally
if(this->rigidBody->GetLambda() < 0.9f)
{
forwardVelocity += walkDirection*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z)) * walkSpeed*0.2f;
if(forwardSpeed < maxSpeed)
{
forwardVelocity += walkDirection*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z)) * walkSpeed;
}
if(rightSpeed < maxSpeed)
{
rightVelocity += walkDirection*Oyster::Math::Float3(fabs(rightDir.x), abs(rightDir.y), fabs(rightDir.z)) * walkSpeed;
}
}
if(rightSpeed < maxSpeed)
// If in the air, accelerate slower
if(this->rigidBody->GetLambda() >= 0.9f)
{
rightVelocity += walkDirection*Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z)) * walkSpeed*0.2f;
if(forwardSpeed < maxSpeed)
{
forwardVelocity += walkDirection*Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z)) * walkSpeed*0.2f;
}
if(rightSpeed < maxSpeed)
{
rightVelocity += walkDirection*Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z)) * walkSpeed*0.2f;
}
}
}
// Adjust velocities so no squaring occurs
forwardVelocity *= Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z));
rightVelocity *= Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z));
upVelocity *= Oyster::Math::Float3(fabs(upDir.x), fabs(upDir.y), fabs(upDir.z));
this->rigidBody->SetLinearVelocity(forwardVelocity+rightVelocity+upVelocity);
//Jump
if(key_jump > 0.001)
{
this->key_jump -= this->gameInstance->GetFrameTime();
if(this->rigidBody->GetLambda() < 0.9f)
{
Oyster::Math::Float3 up = this->rigidBody->GetState().centerPos.GetNormalized();
this->rigidBody->ApplyImpulse(up*this->rigidBody->GetState().mass*20);
this->playerState = PLAYER_STATE::PLAYER_STATE_JUMPING;
}
}
}
// Adjust velocities so no squaring occurs
forwardVelocity *= Oyster::Math::Float3(fabs(forwardDir.x), fabs(forwardDir.y), fabs(forwardDir.z));
rightVelocity *= Oyster::Math::Float3(fabs(rightDir.x), fabs(rightDir.y), fabs(rightDir.z));
upVelocity *= Oyster::Math::Float3(fabs(upDir.x), fabs(upDir.y), fabs(upDir.z));
this->rigidBody->SetLinearVelocity(forwardVelocity+rightVelocity+upVelocity);
//Jump
if(key_jump > 0.001)
else
{
this->key_jump -= this->gameInstance->GetFrameTime();
if(this->rigidBody->GetLambda() < 0.9f)
// player is dead
// TODO move this logic to lvl
this->deathTimeLeft -= gameInstance->GetFrameTime();
if( this->deathTimeLeft <= 0)
{
Oyster::Math::Float3 up = this->rigidBody->GetState().centerPos.GetNormalized();
this->rigidBody->ApplyImpulse(up*this->rigidBody->GetState().mass*20);
this->playerState = PLAYER_STATE::PLAYER_STATE_JUMPING;
Respawn( Oyster::Math::Float3( -50, 180, 0));
}
}
//this->weapon->Update(0.01f);
}
void Player::EndFrame()
{
//Object::EndFrame();
}
@ -258,10 +266,15 @@ void Player::UseWeapon(const WEAPON_FIRE &usage)
void Player::Respawn(Oyster::Math::Float3 spawnPoint)
{
this->life = 100;
this->playerState = PLAYER_STATE::PLAYER_STATE_IDLE;
this->lookDir = Oyster::Math::Float4(1,0,0);
this->rigidBody->SetPosition(spawnPoint);
if( this->playerState == PLAYER_STATE_DEAD)
{
this->life = 100;
this->playerState = PLAYER_STATE::PLAYER_STATE_IDLE;
//this->lookDir = Oyster::Math::Float4(1,0,0);
this->rigidBody->SetPosition(spawnPoint);
this->gameInstance->onRespawnFnc( this, spawnPoint);
this->gameInstance->onDamageTakenFnc( this, this->life);
}
}
void Player::SetLookDir(const Oyster::Math3D::Float3& lookDir)
@ -321,13 +334,17 @@ PLAYER_STATE Player::GetState() const
void Player::DamageLife(int damage)
{
this->life -= damage;
this->life = 0;
if(this->life <= 0)
if( this->playerState != PLAYER_STATE_DEAD)
{
this->life = 0;
playerState = PLAYER_STATE_DEAD;
this->gameInstance->onDisableFnc(this, 0.0f);
this->life -= damage;
this->gameInstance->onDamageTakenFnc( this, this->life);
if(this->life <= 0)
{
this->life = 0;
playerState = PLAYER_STATE_DEAD;
this->deathTimeLeft = this->deathTime;
this->gameInstance->onDeadFnc(this, this->deathTimeLeft);
}
}
}

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

@ -100,6 +100,8 @@ namespace GameLogic
Oyster::Math::Float rotationUp;
float deathTime;
float deathTimeLeft;
bool hasTakenDamage;
float invincibleCooldown;

6
Code/Game/GameProtocols/ObjectProtocols.h
View File

@ -75,13 +75,15 @@ namespace GameLogic
}
Protocol_ObjectDamage(Oyster::Network::CustomNetProtocol& p)
{
this->object_ID = p[1].value.netInt;
this->healthLost = p[2].value.netFloat;
}
Protocol_ObjectDamage(int id, float hp)
{
this->protocol[0].value = protocol_Gameplay_ObjectDamage;
this->protocol[0].type = Oyster::Network::NetAttributeType_Short;
this->protocol[1].type = Oyster::Network::NetAttributeType_Int;
this->protocol[2].type = Oyster::Network::NetAttributeType_Float;
object_ID = id;

5
Code/Game/GameServer/GameSession.h
View File

@ -99,7 +99,10 @@ namespace DanBias
//Callback method recieving from gamelogic
static void ObjectMove ( GameLogic::IObjectData* movedObject );
static void ObjectDisabled ( GameLogic::IObjectData* movedObject, float seconds );
static void ObjectDamaged ( GameLogic::IObjectData* movedObject, float hp );
static void ObjectRespawned ( GameLogic::IObjectData* movedObject, Oyster::Math::Float3 spawnPos );
static void ObjectDead ( GameLogic::IObjectData* movedObject, float seconds );
//Private member variables
private:
Utility::DynamicMemory::DynamicArray<gClient> gClients;

19
Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp
View File

@ -90,7 +90,7 @@ using namespace DanBias;
{
for (unsigned int i = 0; i < this->gClients.Size(); i++)
{
if(this->gClients[i] )
if(this->gClients[i] && !this->gClients[i]->IsInvalid())
{
this->gClients[i]->UpdateClient();
}
@ -101,7 +101,7 @@ using namespace DanBias;
bool returnValue = false;
for (unsigned int i = 0; i < this->gClients.Size(); i++)
{
if(this->gClients[i])
if(this->gClients[i] && !this->gClients[i]->IsInvalid())
{
this->gClients[i]->GetClient()->Send(message);
returnValue = true;
@ -115,7 +115,7 @@ using namespace DanBias;
{
for (unsigned int i = 0; i < this->gClients.Size(); i++)
{
if(this->gClients[i] && this->gClients[i]->GetClient()->GetID() == ID)
if(this->gClients[i] && !this->gClients[i]->IsInvalid() && this->gClients[i]->GetClient()->GetID() == ID)
{
this->gClients[i]->GetClient()->Send(protocol);
return true;
@ -150,7 +150,18 @@ using namespace DanBias;
{
GameSession::gameSession->Send(Protocol_ObjectDisable(movedObject->GetID(), seconds).GetProtocol());
}
void GameSession::ObjectDamaged( GameLogic::IObjectData* movedObject, float hp )
{
GameSession::gameSession->Send(Protocol_ObjectDamage(movedObject->GetID(), hp).GetProtocol());
}
void GameSession::ObjectRespawned( GameLogic::IObjectData* movedObject, Oyster::Math::Float3 spawnPos )
{
GameSession::gameSession->Send(Protocol_ObjectRespawn(movedObject->GetID(), spawnPos).GetProtocol());
}
void GameSession::ObjectDead( GameLogic::IObjectData* movedObject, float seconds )
{
GameSession::gameSession->Send(Protocol_ObjectDie(movedObject->GetID(), seconds).GetProtocol());
}
//*****************************************************//
//****************** Protocol methods *****************//
//******************************************************************************************************************//

7
Code/Game/GameServer/Implementation/GameSession_General.cpp
View File

@ -36,8 +36,8 @@ GameSession::GameSession()
this->isCreated = false;
this->isRunning = false;
this->gameSession = this;
this->logicFrameTime = DELTA_TIME_20;
this->networkFrameTime = DELTA_TIME_20;
this->logicFrameTime = DELTA_TIME_60;
this->networkFrameTime = DELTA_TIME_60;
this->networkTimer.reset();
this->logicTimer.reset();
@ -108,6 +108,9 @@ bool GameSession::Create(GameDescription& desc, bool forceStart)
/* Set some game instance data options */
this->gameInstance.SetSubscription(GameSession::ObjectMove);
this->gameInstance.SetSubscription(GameSession::ObjectDisabled);
this->gameInstance.SetHpSubscription(GameSession::ObjectDamaged);
this->gameInstance.SetRespawnSubscription(GameSession::ObjectRespawned);
this->gameInstance.SetDeadSubscription(GameSession::ObjectDead);
this->gameInstance.SetFPS(60);
this->description.clients.Clear();

2
Code/Game/LanServer/GameServerDebugEnvironment/Source.cpp
View File

@ -32,7 +32,7 @@ int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdSh
GameServerAPI::GameSetGameMode(L"free-for-all");
GameServerAPI::GameSetGameName(L"DebugServer");
GameServerAPI::GameSetGameTime(15);
GameServerAPI::GameSetMapName(L"2ofAll.bias");
GameServerAPI::GameSetMapName(L"erik_250.bias");
GameServerAPI::GameSetMaxClients(10);
if(GameServerAPI::GameStart(true))

31
Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.cpp
View File

@ -291,7 +291,7 @@ void API_Impl::UpdateWorld()
simpleBody->SetPreviousVelocity(simpleBody->GetLinearVelocity());
}
this->dynamicsWorld->stepSimulation(this->timeStep, 1, this->timeStep);
this->dynamicsWorld->stepSimulation(this->timeStep, 10, this->timeStep);
ICustomBody::State state;
@ -314,8 +314,33 @@ void API_Impl::UpdateWorld()
ICustomBody* bodyA = (ICustomBody*)obA->getUserPointer();
ICustomBody* bodyB = (ICustomBody*)obB->getUserPointer();
bodyA->CallSubscription_AfterCollisionResponse(bodyA, bodyB, 0.0f);
bodyB->CallSubscription_AfterCollisionResponse(bodyB, bodyA, 0.0f);
int numContacts = contactManifold->getNumContacts();
for (int j=0;j<numContacts;j++)
{
btManifoldPoint& pt = contactManifold->getContactPoint(j);
if (pt.getDistance()<0.f)
{
if(bodyA->GetState().mass == 40 && bodyB->GetState().centerPos == Float3::null)
{
const char* breakPoint = "STOP";
}
if(bodyB->GetState().mass == 40 && bodyA->GetState().centerPos == Float3::null)
{
const char* breakPoint = "STOP";
}
const btVector3& ptA = pt.getPositionWorldOnA();
const btVector3& ptB = pt.getPositionWorldOnB();
const btVector3& normalOnB = pt.m_normalWorldOnB;
bodyA->CallSubscription_AfterCollisionResponse(bodyA, bodyB, 0.0f);
bodyB->CallSubscription_AfterCollisionResponse(bodyB, bodyA, 0.0f);
}
}
}
}

6
Code/Physics/GamePhysics/Implementation/SimpleRigidBody.cpp
View File

@ -22,6 +22,8 @@ SimpleRigidBody::SimpleRigidBody()
this->state.restitutionCoeff = 0.0f;
this->state.reach = Float3(0.0f, 0.0f, 0.0f);
this->collisionFlags = 0;
this->afterCollision = NULL;
this->onMovement = NULL;
@ -85,7 +87,7 @@ void SimpleRigidBody::SetMotionState(btDefaultMotionState* motionState)
void SimpleRigidBody::SetRigidBody(btRigidBody* rigidBody)
{
this->rigidBody = rigidBody;
this->collisionFlags = rigidBody->getCollisionFlags();
}
void SimpleRigidBody::SetSubscription(EventAction_AfterCollisionResponse function)
@ -421,7 +423,7 @@ void SimpleRigidBody::MoveToLimbo()
void SimpleRigidBody::ReleaseFromLimbo()
{
this->rigidBody->setCollisionFlags(btCollisionObject::CF_KINEMATIC_OBJECT);
this->rigidBody->setCollisionFlags(this->collisionFlags);
}
void SimpleRigidBody::SetPreviousVelocity(::Oyster::Math::Float3 velocity)

2
Code/Physics/GamePhysics/Implementation/SimpleRigidBody.h
View File

@ -93,6 +93,8 @@ namespace Oyster
btVector3 raySource[2];
btVector3 rayTarget[2];
btScalar rayLambda[2];
int collisionFlags;
};
}
}