opengta/OpenGTA
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
net
OpenGTA/entity_controller.cpp

646 lines
17 KiB
C++
Executable File
Raw Permalink Blame History

/************************************************************************
* Copyright (c) 2005-2007 tok@openlinux.org.uk *
* *
* This software is provided as-is, without any express or implied *
* warranty. In no event will the authors be held liable for any *
* damages arising from the use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute *
* it freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must *
* not claim that you wrote the original software. If you use this *
* software in a product, an acknowledgment in the product documentation *
* would be appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must *
* not be misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source *
* distribution. *
************************************************************************/
#define _USE_MATH_DEFINES
#include <cmath>
#include "entity_controller.h"
#include "log.h"
#include "m_exceptions.h"
#include "opengta.h"
#include "dataholder.h"
float slope_height_offset(unsigned char slope_type, float dx, float dz);
namespace OpenGTA {
float heightOverTerrain(Eigen::Vector3f v) {
float x, y, z;
x = floor(v.x());
y = floor(v.y());
z = floor(v.z());
PHYSFS_uint8 x_b, z_b;
x_b = (PHYSFS_uint8)x;
z_b = (PHYSFS_uint8)z;
if (y < 0.0f) {
//ERROR << "Below level! at coords: " << v.x << ", " << v.y << ", " << v.z << std::endl;
return 1.0f;
}
if (x < 0 || x > 255 || z < 0 || z > 255) {
//ERROR << "x = " << x << "(" << v.x << ") z = " << z << " (" << v.z << ")" << std::endl;
throw E_OUTOFRANGE("invalid x/z pos");
}
if (y > 20) {
INFO << y << " seems a bit high; going to 20" << std::endl;
INFO << x << " " << z << std::endl;
y = 20;
}
OpenGTA::Map & map = OpenGTA::MapHolder::Instance().get();
while (y >= map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f)
y -= 1.0f;
while (y < map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f) {
OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(x_b, z_b, (PHYSFS_uint8)y);
assert(block);
if (block->blockType() > 0) {
float bz = slope_height_offset(block->slopeType(), v.x() - x, v.z() - z);
if (block->slopeType() == 0 && (block->blockType() != 5 &&
block->blockType() != 6))
bz -= 1.0f;
//INFO << "hit " << int(block->blockType()) << " at " << int(y) << std::endl;
return v.y() - (y + bz);
}
y -= 1.0f;
}
y = floor(v.y()) + 1.0f;
while (y < map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f) {
OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(x_b, z_b, (PHYSFS_uint8)y);
assert(block);
if (block->blockType() > 0) {
float bz = slope_height_offset(block->slopeType(), v.x() - x, v.z() - z);
if (block->slopeType() == 0 && (block->blockType() != 5
&& block->blockType() != 6))
bz -= 1.0f;
//INFO << "hit " << int(block->blockType()) << " at " << int(y) << std::endl;
return v.y() - (y + bz);
}
y += 1.0f;
}
INFO << "should this be reached?" << std::endl;
return 1.0f;
}
PlayerPedController::PlayerPedController()
{
pos = Eigen::Vector3f{ 12.0f, 6.1f, 12.0f };
}
void PlayerPedController::setMoveForward()
{
pressedButtons = pressedButtons | 0b00000001;
}
void PlayerPedController::setMoveBack()
{
pressedButtons = pressedButtons | 0b00000010;
}
void PlayerPedController::setTurnLeft()
{
pressedButtons = pressedButtons | 0b00000100;
}
void PlayerPedController::setTurnRight()
{
pressedButtons = pressedButtons | 0b00001000;
}
void PlayerPedController::releaseMoveForward()
{
pressedButtons = pressedButtons & 0b11111110;
}
void PlayerPedController::releaseMoveBack()
{
pressedButtons = pressedButtons & 0b11111101;
}
void PlayerPedController::releaseTurnLeft()
{
pressedButtons = pressedButtons & 0b1111011;
}
void PlayerPedController::releaseTurnRight()
{
pressedButtons = pressedButtons & 0b11110111;
}
bool PlayerPedController::isMoveForward()
{
return (pressedButtons & 0b00000001) > 0;
}
bool PlayerPedController::isMoveBack()
{
return (pressedButtons & 0b00000010) > 0;
}
bool PlayerPedController::isTurnLeft()
{
return (pressedButtons & 0b00000100) > 0;
}
bool PlayerPedController::isTurnRight()
{
return (pressedButtons & 0b00001000) > 0;
}
int PlayerPedController::getMove()
{
if (isMoveForward() && isMoveBack())
{
return 0;
}
else if (isMoveForward())
{
return 1;
}
else if (isMoveBack())
{
return -1;
}
else
{
return 0;
}
}
bool PlayerPedController::getRunning()
{
return 1;
}
int PlayerPedController::getTurn()
{
if (isTurnLeft() && isTurnRight())
{
return 0;
}
else if (isTurnLeft())
{
return 1;
}
else if (isTurnRight())
{
return -1;
}
else
{
return 0;
}
}
void PlayerPedController::updatePos(uint32_t delta)
{
static const float CONST_ROTATE_VELOCITY = 0.2f;
static const float CONST_MOVE_VELOCITY = 0.001f;
Eigen::Vector3f moveDelta{ 0, 0, 0 };
switch (getTurn()) {
case -1:
rot -= CONST_ROTATE_VELOCITY * delta;
break;
case 1:
rot += CONST_ROTATE_VELOCITY * delta;
break;
case 0:
break;
}
if (rot >= 360.0f)
{
rot -= 360.0f;
}
if (rot < 0.0f)
{
rot += 360.0f;
}
switch (getMove()) {
case -1:
moveDelta(0) -= sin(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
moveDelta(2) -= cos(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
break;
case 1:
moveDelta(0) += sin(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
moveDelta(2) += cos(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
break;
case 2:
moveDelta(0) += sin(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
moveDelta(2) += cos(rot * M_PI / 180.0f) * CONST_MOVE_VELOCITY * delta;
break;
case 0:
break;
}
auto newPos = pos + moveDelta;
int inGroundContact = checkInGroundContact(newPos);
if (inGroundContact)
{
tryMove(newPos);
}
if (!inGroundContact) {
speedForces(1) += 0.0005f *delta;
pos(1) -= speedForces(1);
if (speedForces(1) < 0.2f)
{
INFO << "bridge step? height: " << pos.y() << " speed: " << speedForces.y() << std::endl;
}
else
{
INFO << "FALLING " << pos.y() << " speed " << speedForces.y() << std::endl;
}
}
else {
if (speedForces(1) > 0.1)
{
INFO << "impacting with speed: " << speedForces.y() << std::endl;
}
speedForces(1) = 0.0f;
}
}
int PlayerPedController::checkInGroundContact(Eigen::Vector3f nPos)
{
int inGroundContact;
float hot = heightOverTerrain(nPos);
if (hot > 0.3f)
inGroundContact = 0;
else if (hot < 0.0) {
WARN << "gone below: " << hot << " at " << nPos.x() << ", " << nPos.y() << ", " << nPos.z() << std::endl;
nPos(1) -= (hot - 0.3f);
//nPos.y += 1;
//INFO << nPos.y << std::endl;
inGroundContact = 1;
}
else {
inGroundContact = 1;
nPos(1) -= hot - 0.1f;
}
return inGroundContact;
}
void PlayerPedController::tryMove(Eigen::Vector3f nPos) {
float x, y, z;
x = floor(nPos.x());
y = floor(nPos.y());
z = floor(nPos.z());
OpenGTA::Map & map = OpenGTA::MapHolder::Instance().get();
OpenGTA::GraphicsBase & graphics = OpenGTA::StyleHolder::Instance().get();
if (y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z)) && y > 0.0f) {
OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z), PHYSFS_uint8(y));
assert(block);
if (block->left && graphics.isBlockingSide(block->left)) {
if (block->isFlat()) {
if (x - pos.x() < 0 && x - pos.x() > -0.2f) {
nPos(0) = (nPos.x() < pos.x()) ? pos.x() : nPos.x();
}
else if (x - pos.x() > 0 && x - pos.x() < 0.2f)
nPos(0) = pos.x();
}
else {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "xblock left: " << x - pos.x() << " tex: " << int(block->left) << std::endl;
#endif
if (x - pos.x() > 0 && x - pos.x() < 0.2f)
nPos(0) = pos.x();
else if (x - pos.x() < 0 && x - pos.x() > -0.2f)
nPos(0) = (nPos.x() < pos.x()) ? pos.x() : nPos.x();
}
}
if (block->right && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "xblock right: " << pos.x() - x - 1 << " tex: " << int(block->right) << std::endl;
#endif
if (pos.x() - x - 1 > 0 && pos.x() - x - 1 < 0.2f) {
nPos(0) = pos.x();
}
else if (pos.x() - x - 1 < 0 && pos.x() - x - 1 > -0.2f)
nPos(0) = (nPos.x() > pos.x()) ? pos.x() : nPos.x();
}
if (block->top && graphics.isBlockingSide(block->top)) {
if (block->isFlat()) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "zblock top: " << z - pos.z() << " tex: " << int(block->top) << std::endl;
#endif
if (z - pos.z() > 0 && z - pos.z() < 0.2f)
nPos(2) = pos.z();
else if (z - pos.z() < 0 && z - pos.z() > -0.2f)
nPos(2) = (nPos.z() < pos.z()) ? pos.z() : nPos.z();
}
else {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "zblock top: " << z - pos.z() << " tex: " << int(block->top) << std::endl;
#endif
if (z - pos.z() > 0 && z - pos.z() < 0.2f)
nPos(2) = pos.z();
else if (z - pos.z() < 0 && z - pos.z() > -0.2f)
nPos(2) = (nPos.z() < pos.z()) ? pos.z() : nPos.z();
}
}
if (block->bottom && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "zblock bottom: " << pos.z() - z - 1 << " tex: " << int(block->bottom) << std::endl;
#endif
if (pos.z() - z - 1 > 0 && pos.z() - z - 1 < 0.2f) {
nPos(2) = pos.z();
}
else if (pos.z() - z - 1 < 0 && pos.z() - z - 1 > -0.2f)
nPos(2) = (nPos.z() > pos.z()) ? pos.z() : nPos.z();
}
if (x >= 1 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x - 1), PHYSFS_uint8(z))) {
block = map.getBlockAtNew(PHYSFS_uint8(x - 1), PHYSFS_uint8(z), PHYSFS_uint8(y));
if (block->right && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "xblock right: " << pos.x() - x << " tex: " << int(block->right) << std::endl;
#endif
if (pos.x() - x < 0.2f) {
nPos(0) = (nPos.x() < pos.x() ? pos.x() : nPos.x());
}
}
}
if (x < 255 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x + 1), PHYSFS_uint8(z))) {
block = map.getBlockAtNew(PHYSFS_uint8(x + 1), PHYSFS_uint8(z), PHYSFS_uint8(y));
if (block->left && graphics.isBlockingSide(block->left)) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "xblock left: " << x + 1 - pos.x() << " tex: " << int(block->left) << std::endl;
#endif
if (block->isFlat()) {
if (x + 1 - pos.x() > 0 && x + 1 - pos.x() < 0.2f)
nPos(0) = (nPos.x() < pos.x() ? nPos.x() : pos.x());
}
else {
if (x + 1 - pos.x() < 0.2f)
nPos(0) = (nPos.x() < pos.x() ? nPos.x() : pos.x());
}
}
}
if (z >= 1 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z - 1))) {
block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z - 1), PHYSFS_uint8(y));
if (block->bottom && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "zblock bottom: " << pos.z() - z << " tex: " << int(block->bottom) << std::endl;
#endif
if (pos.z() - z < 0.2f) {
nPos(2) = (nPos.z() < pos.z() ? pos.z() : nPos.z());
}
}
}
if (z < 255 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z + 1))) {
block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z + 1), PHYSFS_uint8(y));
if (block->top && graphics.isBlockingSide(block->top)) {
#ifdef DEBUG_OLD_PED_BLOCK
INFO << "zblock top: " << z + 1 - pos.z() << " tex: " << int(block->top) << std::endl;
#endif
if (block->isFlat()) {
if (z + 1 - pos.z() > 0 && z + 1 - pos.z() < 0.2f)
nPos(2) = (nPos.z() < pos.z() ? nPos.z() : pos.z());
}
else {
if (z + 1 - pos.z() < 0.2f)
nPos(2) = (nPos.z() < pos.z() ? nPos.z() : pos.z());
}
}
}
//if (inGroundContact)
// pos = nPos;
}
bool obj_blocked = false;
/*
std::list<Car> & list = SpriteManagerHolder::Instance().getList<Car>();
for (std::list<Car>::iterator i = list.begin(); i != list.end(); i++) {
if (isBoxInBox(*i)) {
if (Util::distance(pos(), i->pos()) > Util::distance(nPos, i->pos()))
obj_blocked = true;
}
}*/
if (obj_blocked == false)
{
pos = nPos;
}
}
EntityController::EntityController() :
rawData(0),
dataSet(sizeof(rawData) * 8, (unsigned char*)&rawData) {}
EntityController::EntityController(const EntityController & other) :
rawData(other.rawData),
dataSet(sizeof(rawData) * 8, (unsigned char*)&rawData) {}
void EntityController::zero() {
rawData = 0;
}
void EntityController::setRaw(Storage_T v) {
rawData = v;
}
bool ControllerWithMemory::statusChanged() {
bool res = (rawData != lastRawData);
if (res)
lastRawData = rawData;
return res;
}
void PedController::setTurnLeft(bool press) {
dataSet.set_item(0, press);
}
void PedController::setTurnRight(bool press) {
dataSet.set_item(1, press);
}
void PedController::setMoveForward(bool press) {
dataSet.set_item(2, press);
}
void PedController::setMoveBack(bool press) {
dataSet.set_item(3, press);
}
void PedController::setAction(bool press) {
dataSet.set_item(4, press);
}
void PedController::setJump(bool press) {
dataSet.set_item(5, press);
}
void PedController::setFireWeapon(bool press) {
dataSet.set_item(6, press);
}
signed char PedController::getTurn() {
if (dataSet.get_item(0) && dataSet.get_item(1)) // special: straight ahead
return 0;
if (dataSet.get_item(0))
return 1;
else if (dataSet.get_item(1))
return -1;
return 0;
}
signed char PedController::getMove() {
if (dataSet.get_item(2) && dataSet.get_item(3)) // special: evens out
return 0;
if (dataSet.get_item(2))
return 1;
else if (dataSet.get_item(3))
return -1;
return 0;
}
bool PedController::getAction() {
return dataSet.get_item(4);
}
bool PedController::getJump() {
return dataSet.get_item(5);
}
bool PedController::getFireWeapon() {
return dataSet.get_item(6);
}
void PedController::setRunning(bool yes) {
dataSet.set_item(7, yes);
}
bool PedController::getRunning() {
return dataSet.get_item(7);
}
unsigned char PedController::getActiveWeapon() {
// 0 .. k
unsigned char r = 0;
for (int j = 0; j < 3; ++j) {
if (dataSet.get_item(j + 8))
r += (1 << j);
}
return r;
}
void PedController::setActiveWeapon(unsigned char k) {
if (k > 7) {
throw E_OUTOFRANGE("foo");
}
for (int j = 0; j < 3; ++j) {
if (k & 1u)
dataSet.set_item(j + 8, true);
else
dataSet.set_item(j + 8, false);
k >>= 1;
}
}
#if 0
#include <SDL_events.h>
#include "localplayer.h"
class ConfigurableKeyConsumer {
static const SDLKey sym_array[];
static const int TURN_LEFT = 0;
static const int TURN_RIGHT = 1;
static const int MOVE_FORWARD = 2;
static const int MOVE_BACKWARD = 3;
public:
void handle(const SDL_keysym & ks, bool press) {
PedController & pc = LocalPlayer::Instance().getCtrl();
if (ks.sym == sym_array[TURN_LEFT]) {
pc.setTurnLeft(true);
return;
}
else if (ks.sym == sym_array[TURN_RIGHT]) {
pc.setTurnRight(true);
return;
}
}
};
#endif
#if 0
#include <SDL_events.h>
#include "localplayer.h"
template <class ENTITY>
class ClassicKeyConsumer {
public:
bool handle(const SDL_keysym & ks, bool press);
};
template <> bool ClassicKeyConsumer<PedController>::handle(const SDL_keysym & ks, bool press) {
bool swallow_event = true;
PedController & pc = LocalPlayer::Instance().getEntity().m_control;
switch(ks.sym) {
case SDLK_LEFT:
pc.setTurnLeft(press);
break;
case SDLK_RIGHT:
pc.setTurnRight(press);
break;
case SDLK_UP:
pc.setMoveForward(press);
break;
case SDLK_DOWN:
pc.setMoveBack(press);
break;
case SDLK_RETURN:
pc.setAction(press);
break;
case SDLK_SPACE:
pc.setJump(press);
break;
default:
swallow_event = false;
break;
}
return swallow_event;
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink