mirror of
https://github.com/scummvm/scummvm.git
synced 2025-04-02 10:52:32 -04:00
487 lines
14 KiB
C++
487 lines
14 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2006-2010 - Frictional Games
|
|
*
|
|
* This file is part of Penumbra Overture.
|
|
*/
|
|
|
|
#include "hpl1/penumbra-overture/GameStickArea.h"
|
|
#include "hpl1/engine/engine.h"
|
|
|
|
#include "hpl1/penumbra-overture/Init.h"
|
|
#include "hpl1/penumbra-overture/MapHandler.h"
|
|
#include "hpl1/penumbra-overture/Player.h"
|
|
#include "hpl1/penumbra-overture/PlayerState.h"
|
|
|
|
#include "hpl1/penumbra-overture/GlobalInit.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LOADER
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cAreaLoader_GameStickArea::cAreaLoader_GameStickArea(const tString &asName, cInit *apInit)
|
|
: iArea3DLoader(asName) {
|
|
mpInit = apInit;
|
|
}
|
|
|
|
cAreaLoader_GameStickArea::~cAreaLoader_GameStickArea() {
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
iEntity3D *cAreaLoader_GameStickArea::Load(const tString &asName, const cVector3f &avSize,
|
|
const cMatrixf &a_mtxTransform, cWorld3D *apWorld) {
|
|
cGameStickArea *pArea = hplNew(cGameStickArea, (mpInit, asName));
|
|
|
|
pArea->m_mtxOnLoadTransform = a_mtxTransform;
|
|
|
|
// Create physics data
|
|
iPhysicsWorld *pPhysicsWorld = apWorld->GetPhysicsWorld();
|
|
iCollideShape *pShape = pPhysicsWorld->CreateBoxShape(avSize, NULL);
|
|
Common::Array<iPhysicsBody *> vBodies;
|
|
vBodies.push_back(pPhysicsWorld->CreateBody(asName, pShape));
|
|
|
|
vBodies[0]->SetCollide(false);
|
|
vBodies[0]->SetCollideCharacter(false);
|
|
vBodies[0]->SetMatrix(a_mtxTransform);
|
|
|
|
vBodies[0]->SetUserData(pArea);
|
|
pArea->SetBodies(vBodies);
|
|
|
|
mpInit->mpMapHandler->AddGameEntity(pArea);
|
|
mpInit->mpMapHandler->AddStickArea(pArea);
|
|
|
|
// Return something else later perhaps.
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CONSTRUCTORS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
bool cGameStickArea::mbAllowAttachment = false;
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cGameStickArea::cGameStickArea(cInit *apInit, const tString &asName) : iGameEntity(apInit, asName) {
|
|
mType = eGameEntityType_StickArea;
|
|
|
|
mpAttachedBody = NULL;
|
|
mpLastAttachedBody = NULL;
|
|
|
|
msAttachFunction = "";
|
|
msDetachFunction = "";
|
|
|
|
msAttachSound = "";
|
|
msDetachFunction = "";
|
|
|
|
msAttachSound = "";
|
|
msDetachSound = "";
|
|
|
|
mbMoveBody = true;
|
|
mbRotateBody = true;
|
|
|
|
mbCheckCenterInArea = true;
|
|
|
|
mfPoseTime = 0.2f;
|
|
|
|
mbCanDeatch = true;
|
|
|
|
mfSetMtxTime = 1.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cGameStickArea::~cGameStickArea(void) {
|
|
mpInit->mpMapHandler->RemoveStickArea(this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PUBLIC METHODS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::OnPlayerPick() {
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::Update(float afTimeStep) {
|
|
iPhysicsBody *pAreaBody = mvBodies[0];
|
|
cWorld3D *pWorld = mpInit->mpGame->GetScene()->GetWorld3D();
|
|
|
|
if (mpAttachedBody && mfSetMtxTime < 1) {
|
|
if (mbMoveBody && mbRotateBody) {
|
|
if (mfPoseTime == 0)
|
|
mfSetMtxTime = 1.0f;
|
|
else
|
|
mfSetMtxTime += afTimeStep / mfPoseTime;
|
|
|
|
cMatrixf mtxGoal = pAreaBody->GetWorldMatrix();
|
|
mtxGoal.SetTranslation(pAreaBody->GetWorldPosition() - mpAttachedBody->GetMassCentre());
|
|
|
|
cMatrixf mtxNew = cMath::MatrixSlerp(mfSetMtxTime, mtxAttachedStart, mtxGoal, true);
|
|
|
|
mpAttachedBody->SetMatrix(mtxNew);
|
|
} else if (mbMoveBody && !mbRotateBody) {
|
|
if (mfPoseTime == 0)
|
|
mfSetMtxTime = 1.0f;
|
|
else
|
|
mfSetMtxTime += afTimeStep / mfPoseTime;
|
|
|
|
cVector3f vGoal = pAreaBody->GetWorldPosition() - mpAttachedBody->GetMassCentre();
|
|
|
|
cVector3f vNew = mtxAttachedStart.GetTranslation() * (1 - mfSetMtxTime) +
|
|
vGoal * mfSetMtxTime;
|
|
|
|
mpAttachedBody->SetPosition(vNew);
|
|
} else if (!mbMoveBody && mbRotateBody) {
|
|
if (mfPoseTime == 0)
|
|
mfSetMtxTime = 1.0f;
|
|
else
|
|
mfSetMtxTime += afTimeStep / mfPoseTime;
|
|
|
|
cMatrixf mtxGoal = pAreaBody->GetWorldMatrix();
|
|
|
|
cMatrixf mtxNew = cMath::MatrixSlerp(mfSetMtxTime, mtxAttachedStart, mtxGoal, true);
|
|
|
|
mtxNew.SetTranslation(mpAttachedBody->GetWorldPosition());
|
|
mpAttachedBody->SetMatrix(mtxNew);
|
|
} else {
|
|
mfSetMtxTime = 1.0f;
|
|
}
|
|
|
|
if (mfSetMtxTime >= 1) {
|
|
// Sound
|
|
if (msAttachSound != "") {
|
|
cSoundEntity *pSound = pWorld->CreateSoundEntity("AttachSound", msAttachSound, true);
|
|
if (pSound)
|
|
pSound->SetPosition(pAreaBody->GetWorldPosition());
|
|
}
|
|
|
|
// Particle System
|
|
if (msAttachPS != "") {
|
|
pWorld->CreateParticleSystem("AttachPS", msAttachPS, 1, pAreaBody->GetWorldMatrix());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mpAttachedBody)
|
|
return;
|
|
|
|
iPhysicsWorld *pPhysicsWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();
|
|
iPhysicsBody *pAttachBody = NULL;
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Iterate all bodies in world and check for intersection
|
|
cPhysicsBodyIterator bodyIt = pPhysicsWorld->GetBodyIterator();
|
|
while (bodyIt.HasNext()) {
|
|
iPhysicsBody *pBody = bodyIt.Next();
|
|
|
|
/*if( mpInit->mpPlayer->GetPickedBody() == pBody &&
|
|
( mpInit->mpPlayer->GetState() == ePlayerState_Grab ||
|
|
mpInit->mpPlayer->GetState() == ePlayerState_Move ||
|
|
mpInit->mpPlayer->GetState() == ePlayerState_Push)
|
|
)
|
|
{
|
|
continue;
|
|
}*/
|
|
|
|
if (pBody->IsActive() && pBody->GetCollide() && pBody->GetMass() > 0 &&
|
|
pBody->IsCharacter() == false) {
|
|
// Bounding volume check
|
|
// if(cMath::CheckCollisionBV(*pBody->GetBV(), *pAreaBody->GetBV())==false) continue;
|
|
|
|
bool bCheck = false;
|
|
if (mbCheckCenterInArea) {
|
|
cVector3f vPos = pBody->GetLocalPosition() +
|
|
cMath::MatrixMul(pBody->GetLocalMatrix().GetRotation(),
|
|
pBody->GetMassCentre());
|
|
bCheck = cMath::PointBVCollision(vPos, *pAreaBody->GetBV());
|
|
} else {
|
|
bCheck = cMath::CheckCollisionBV(*pBody->GetBV(), *pAreaBody->GetBV());
|
|
}
|
|
|
|
if (bCheck == false) {
|
|
if (pBody == mpLastAttachedBody) {
|
|
mpLastAttachedBody = NULL;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (pBody == mpLastAttachedBody)
|
|
continue;
|
|
|
|
// Shape collision check.
|
|
cCollideData collideData;
|
|
collideData.SetMaxSize(1);
|
|
bool bCollide = pPhysicsWorld->CheckShapeCollision(pAreaBody->GetShape(),
|
|
pAreaBody->GetLocalMatrix(),
|
|
pBody->GetShape(),
|
|
pBody->GetLocalMatrix(),
|
|
collideData, 1);
|
|
if (bCollide) {
|
|
if (msAttachFunction != "") {
|
|
mbAllowAttachment = false;
|
|
tString sCommand = GetCallbackFunc(msAttachFunction, pBody);
|
|
mpInit->RunScriptCommand(sCommand);
|
|
|
|
if (mbAllowAttachment == false)
|
|
continue;
|
|
}
|
|
|
|
pAttachBody = pBody;
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Do some stuff with the body to be attached.
|
|
if (pAttachBody) {
|
|
// Log("Attaching body %s\n", pAttachBody->GetName().c_str());
|
|
|
|
/////////////////////////
|
|
// If in an interact state, set the previous state
|
|
if (mpInit->mpPlayer->GetPushBody() == pAttachBody &&
|
|
(mpInit->mpPlayer->GetState() == ePlayerState_Grab ||
|
|
mpInit->mpPlayer->GetState() == ePlayerState_Move ||
|
|
mpInit->mpPlayer->GetState() == ePlayerState_Push)) {
|
|
// Log(" Setting a prev state\n");
|
|
|
|
ePlayerState state = mpInit->mpPlayer->GetState();
|
|
ePlayerState prev = mpInit->mpPlayer->GetStateData(state)->mPreviuosState;
|
|
if (prev == ePlayerState_InteractMode)
|
|
mpInit->mpPlayer->ChangeState(ePlayerState_InteractMode);
|
|
else
|
|
mpInit->mpPlayer->ChangeState(ePlayerState_Normal);
|
|
}
|
|
|
|
/////////////////////////
|
|
// Snap it into place.
|
|
// pAttachBody->SetMatrix(pAreaBody->GetWorldMatrix());
|
|
// pAttachBody->SetPosition(pAreaBody->GetWorldPosition() - pAttachBody->GetMassCentre());
|
|
mtxAttachedStart = pAttachBody->GetLocalMatrix();
|
|
|
|
mfSetMtxTime = 0;
|
|
|
|
pAttachBody->SetLinearVelocity(0);
|
|
pAttachBody->SetAngularVelocity(0);
|
|
|
|
mbBodyGravity = pAttachBody->GetGravity();
|
|
pAttachBody->SetGravity(false);
|
|
|
|
mfBodyMass = pAttachBody->GetMass();
|
|
pAttachBody->SetMass(0);
|
|
|
|
mpAttachedBody = pAttachBody;
|
|
mpLastAttachedBody = mpAttachedBody;
|
|
|
|
// Log("Attaching body!\n");
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::DetachBody() {
|
|
if (mpAttachedBody) {
|
|
// Log("Dettached body %s\n", mpAttachedBody->GetName().c_str());
|
|
|
|
cWorld3D *pWorld = mpInit->mpGame->GetScene()->GetWorld3D();
|
|
iPhysicsBody *pAreaBody = mvBodies[0];
|
|
|
|
// Callback function
|
|
if (msDetachFunction != "") {
|
|
tString sCommand = GetCallbackFunc(msDetachFunction, mpAttachedBody);
|
|
mpInit->RunScriptCommand(sCommand);
|
|
}
|
|
|
|
// Sound
|
|
if (msDetachSound != "") {
|
|
cSoundEntity *pSound = pWorld->CreateSoundEntity("DetachSound", msDetachSound, true);
|
|
if (pSound)
|
|
pSound->SetPosition(pAreaBody->GetWorldPosition());
|
|
}
|
|
|
|
// Particle System
|
|
if (msDetachPS != "") {
|
|
pWorld->CreateParticleSystem("DetachPS", msDetachPS, 1, pAreaBody->GetWorldMatrix());
|
|
}
|
|
|
|
mpAttachedBody->SetGravity(true);
|
|
mpAttachedBody->SetMass(mfBodyMass);
|
|
mpAttachedBody->SetEnabled(true);
|
|
|
|
// Log("Body mass: %f\n",mpAttachedBody->GetMass());
|
|
|
|
mpAttachedBody = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
bool cGameStickArea::GetCanDeatch() {
|
|
if (mfSetMtxTime < 1)
|
|
return false;
|
|
|
|
return mbCanDeatch;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
tString cGameStickArea::GetCallbackFunc(const tString &asFunc, iPhysicsBody *apBody) {
|
|
return asFunc + "(\"" + msName + "\",\"" + apBody->GetName() + "\")";
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::OnPostSceneDraw() {
|
|
// iPhysicsBody *pAreaBody = mvBodies[0];
|
|
|
|
// pAreaBody->RenderDebugGeometry(mpInit->mpGame->GetGraphics()->GetLowLevel(),cColor(1,1));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PRIVATE METHODS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// SAVE OBJECT STUFF
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
kBeginSerialize(cGameStickArea_SaveData, iGameEntity_SaveData)
|
|
kSerializeVar(mvSize, eSerializeType_Vector3f)
|
|
|
|
kSerializeVar(msAttachFunction, eSerializeType_String)
|
|
kSerializeVar(msDetachFunction, eSerializeType_String)
|
|
|
|
kSerializeVar(msAttachSound, eSerializeType_String)
|
|
kSerializeVar(msDetachSound, eSerializeType_String)
|
|
|
|
kSerializeVar(msAttachPS, eSerializeType_String)
|
|
kSerializeVar(msDetachPS, eSerializeType_String)
|
|
|
|
kSerializeVar(mbCanDeatch, eSerializeType_Bool)
|
|
|
|
kSerializeVar(msAttachedBody, eSerializeType_String)
|
|
|
|
kSerializeVar(mfSetMtxTime, eSerializeType_Float32)
|
|
|
|
kSerializeVar(mbCheckCenterInArea, eSerializeType_Bool)
|
|
|
|
kSerializeVar(mfPoseTime, eSerializeType_Float32)
|
|
kEndSerialize()
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
iGameEntity *cGameStickArea_SaveData::CreateEntity() {
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
iGameEntity_SaveData *cGameStickArea::CreateSaveData() {
|
|
return hplNew(cGameStickArea_SaveData, ());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::SaveToSaveData(iGameEntity_SaveData *apSaveData) {
|
|
super::SaveToSaveData(apSaveData);
|
|
cGameStickArea_SaveData *pData = static_cast<cGameStickArea_SaveData *>(apSaveData);
|
|
|
|
kCopyToVar(pData, msAttachFunction);
|
|
kCopyToVar(pData, msDetachFunction);
|
|
|
|
kCopyToVar(pData, msAttachSound);
|
|
kCopyToVar(pData, msDetachSound);
|
|
|
|
kCopyToVar(pData, msAttachPS);
|
|
kCopyToVar(pData, msDetachPS);
|
|
|
|
kCopyToVar(pData, mbCanDeatch);
|
|
|
|
kCopyToVar(pData, mbCheckCenterInArea);
|
|
|
|
kCopyToVar(pData, mfPoseTime);
|
|
|
|
kCopyToVar(pData, mfSetMtxTime);
|
|
|
|
pData->mvSize = mvBodies[0]->GetShape()->GetSize();
|
|
|
|
if (mpAttachedBody) {
|
|
pData->msAttachedBody = mpAttachedBody->GetName();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::LoadFromSaveData(iGameEntity_SaveData *apSaveData) {
|
|
super::LoadFromSaveData(apSaveData);
|
|
cGameStickArea_SaveData *pData = static_cast<cGameStickArea_SaveData *>(apSaveData);
|
|
|
|
kCopyFromVar(pData, msAttachFunction);
|
|
kCopyFromVar(pData, msDetachFunction);
|
|
|
|
kCopyFromVar(pData, msAttachSound);
|
|
kCopyFromVar(pData, msDetachSound);
|
|
|
|
kCopyFromVar(pData, msAttachPS);
|
|
kCopyFromVar(pData, msDetachPS);
|
|
|
|
kCopyFromVar(pData, mbCanDeatch);
|
|
|
|
kCopyFromVar(pData, mbCheckCenterInArea);
|
|
|
|
kCopyFromVar(pData, mfPoseTime);
|
|
|
|
kCopyFromVar(pData, mfSetMtxTime);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cGameStickArea::SetupSaveData(iGameEntity_SaveData *apSaveData) {
|
|
super::SetupSaveData(apSaveData);
|
|
cGameStickArea_SaveData *pData = static_cast<cGameStickArea_SaveData *>(apSaveData);
|
|
|
|
if (pData->msAttachedBody != "") {
|
|
iPhysicsWorld *pWorld = mpInit->mpGame->GetScene()->GetWorld3D()->GetPhysicsWorld();
|
|
mpAttachedBody = pWorld->GetBody(pData->msAttachedBody);
|
|
mpLastAttachedBody = mpAttachedBody;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------
|