Mirrors/openrw
1
0
Fork 0
mirror of https://github.com/rwengine/openrw.git synced 2024-11-13 22:24:17 +01:00
Code Issues Projects Releases Activity
36a2c57d91
openrw/rwgame/states/IngameState.cpp
dan 810c6658d0 use openFilePath to open data files
2016-09-07 22:06:38 +01:00

540 lines
16 KiB
C++
Raw Blame History

#include "IngameState.hpp"
#include "RWGame.hpp"
#include "PauseState.hpp"
#include "DebugState.hpp"
#include "DrawUI.hpp"
#include <ai/PlayerController.hpp>
#include <objects/CharacterObject.hpp>
#include <objects/VehicleObject.hpp>
#include <objects/ItemPickup.hpp>
#include <dynamics/CollisionInstance.hpp>
#include <data/Model.hpp>
#include <items/WeaponItem.hpp>
#include <engine/GameWorld.hpp>
#include <engine/GameState.hpp>
#include <script/ScriptMachine.hpp>
#include <dynamics/RaycastCallbacks.hpp>
#include <glm/gtc/constants.hpp>
#include <unordered_map>
constexpr float kAutoLookTime = 2.f;
constexpr float kAutolookMinVelocity = 0.2f;
const float kMaxRotationRate = glm::half_pi<float>();
const float kCameraPitchLimit = glm::quarter_pi<float>() * 0.5f;
const float kVehicleCameraPitch = glm::half_pi<float>() - glm::quarter_pi<float>() * 0.25f;
// Hardcoded Controls SDLK_* -> GameInputState::Control
const std::unordered_multimap<int, GameInputState::Control> kDefaultControls = {
/* On Foot */
{ SDLK_LCTRL, GameInputState::FireWeapon },
{ SDLK_KP_0, GameInputState::FireWeapon },
{ SDLK_KP_ENTER, GameInputState::NextWeapon },
{ SDLK_KP_PERIOD, GameInputState::LastWeapon },
{ SDLK_w, GameInputState::GoForward },
{ SDLK_UP, GameInputState::GoForward },
{ SDLK_s, GameInputState::GoBackwards },
{ SDLK_DOWN, GameInputState::GoBackwards },
{ SDLK_a, GameInputState::GoLeft },
{ SDLK_LEFT, GameInputState::GoLeft },
{ SDLK_d, GameInputState::GoRight },
{ SDLK_RIGHT, GameInputState::GoRight },
{ SDLK_PAGEUP, GameInputState::ZoomIn },
{ SDLK_z, GameInputState::ZoomIn },
{ SDLK_PAGEDOWN, GameInputState::ZoomOut },
{ SDLK_x, GameInputState::ZoomOut },
{ SDLK_f, GameInputState::EnterExitVehicle },
{ SDLK_RETURN, GameInputState::EnterExitVehicle },
{ SDLK_c, GameInputState::ChangeCamera },
{ SDLK_HOME, GameInputState::ChangeCamera },
{ SDLK_RCTRL, GameInputState::Jump },
{ SDLK_SPACE, GameInputState::Jump },
{ SDLK_LSHIFT, GameInputState::Sprint },
{ SDLK_RSHIFT, GameInputState::Sprint },
{ SDLK_LALT, GameInputState::Walk },
{ SDLK_DELETE, GameInputState::AimWeapon },
{ SDLK_CAPSLOCK, GameInputState::LookBehind },
/* In Vehicle */
{ SDLK_LCTRL, GameInputState::VehicleFireWeapon },
{ SDLK_a, GameInputState::VehicleLeft },
{ SDLK_LEFT, GameInputState::VehicleLeft },
{ SDLK_d, GameInputState::VehicleRight },
{ SDLK_RIGHT, GameInputState::VehicleRight },
{ SDLK_w, GameInputState::VehicleAccelerate },
{ SDLK_UP, GameInputState::VehicleAccelerate },
{ SDLK_d, GameInputState::VehicleBrake },
{ SDLK_DOWN, GameInputState::VehicleBrake },
{ SDLK_INSERT, GameInputState::ChangeRadio },
{ SDLK_r, GameInputState::ChangeRadio },
{ SDLK_LSHIFT, GameInputState::Horn },
{ SDLK_RSHIFT, GameInputState::Horn },
{ SDLK_KP_PLUS, GameInputState::Submission },
{ SDLK_CAPSLOCK, GameInputState::Submission },
{ SDLK_RCTRL, GameInputState::Handbrake },
{ SDLK_SPACE, GameInputState::Handbrake },
{ SDLK_KP_9, GameInputState::VehicleAimUp },
{ SDLK_KP_2, GameInputState::VehicleAimDown },
{ SDLK_KP_4, GameInputState::VehicleAimLeft },
{ SDLK_KP_6, GameInputState::VehicleAimRight },
{ SDLK_KP_9, GameInputState::VehicleDown },
{ SDLK_KP_2, GameInputState::VehicleUp },
{ SDLK_KP_1, GameInputState::LookLeft },
{ SDLK_q, GameInputState::LookLeft },
{ SDLK_KP_2, GameInputState::LookRight },
{ SDLK_e, GameInputState::LookRight },
};
IngameState::IngameState(RWGame* game, bool newgame, const std::string& save)
: State(game)
, started(false)
, save(save)
, newgame(newgame)
, autolookTimer(0.f)
, camMode(IngameState::CAMERA_NORMAL)
, m_cameraAngles { 0.f, glm::half_pi<float>() }
, m_invertedY(game->getConfig().getInputInvertY())
, m_vehicleFreeLook(true)
{
}
void IngameState::startTest()
{
auto playerChar = getWorld()->createPlayer({270.f, -605.f, 40.f});
getWorld()->state->playerObject = playerChar->getGameObjectID();
glm::vec3 itemspawn(276.5f, -609.f, 36.5f);
for (int i = 1; i < maxInventorySlots; ++i) {
auto item = getWorld()->getInventoryItem(i);
getWorld()->createPickup(itemspawn, item->getModelID(),
PickupObject::OnStreet);
itemspawn.x += 2.5f;
}
auto carPos = glm::vec3( 286.f, -591.f, 37.f );
auto carRot = glm::angleAxis(glm::radians(90.f), glm::vec3(0.f, 0.f, 1.f));
//auto boatPos = glm::vec3( -1000.f, -1040.f, 5.f );
int i = 0;
for( auto& vi : getWorld()->data->objectTypes ) {
switch( vi.first ) {
case 140: continue;
case 141: continue;
}
if( vi.second->class_type == ObjectInformation::_class("CARS") )
{
if ( i++ > 20 ) break;
auto vehicle = std::static_pointer_cast<VehicleData>(vi.second);
auto& sp = carPos;
auto& sr = carRot;
auto v = getWorld()->createVehicle(vi.first, sp, sr);
sp += sr * glm::vec3( 2.f + v->info->handling.dimensions.x, 0.f, 0.f);
}
}
}
void IngameState::startGame()
{
game->startScript("data/main.scm");
game->getScript()->startThread(0);
getWorld()->sound.playBackground( getWorld()->data->getDataPath() + "/audio/City.wav" );
}
void IngameState::enter()
{
if( ! started )
{
if( newgame )
{
if( save.empty() )
{
startGame();
}
else if( save == "test" )
{
startTest();
}
else {
game->loadGame( save );
}
}
started = true;
}
getWindow().hideCursor();
}
void IngameState::exit()
{
}
void IngameState::tick(float dt)
{
auto world = getWorld();
autolookTimer = std::max(autolookTimer - dt, 0.f);
// Update displayed money value
// @todo the game uses another algorithm which is non-linear
{
float moneyFrequency = 1.0f / 30.0f;
moneyTimer += dt;
while (moneyTimer >= moneyFrequency) {
int32_t difference = world->state->playerInfo.money - world->state->playerInfo.displayedMoney;
// Generates 0, 1 (difference < 100), 12 (difference < 1000), 123 (difference < 10000), .. etc.
// Negative input will result in negative output
auto GetIncrement = [](int32_t difference) -> int32_t {
// @todo is this correct for difference >= 1000000000 ?
int32_t r = 1;
int32_t i = 2;
if (difference == 0) { return 0; }
while (std::abs(difference) >= 100) {
difference /= 10;
r = r * 10 + i;
i++;
}
return (difference < 0) ? -r : r;
};
world->state->playerInfo.displayedMoney += GetIncrement(difference);
moneyTimer -= moneyFrequency;
}
}
auto player = game->getPlayer();
const auto& input = world->state->input;
if( player && player->isInputEnabled() )
{
float viewDistance = 4.f;
switch( camMode )
{
case IngameState::CAMERA_CLOSE:
viewDistance = 2.f;
break;
case IngameState::CAMERA_NORMAL:
viewDistance = 4.0f;
break;
case IngameState::CAMERA_FAR:
viewDistance = 6.f;
break;
case IngameState::CAMERA_TOPDOWN:
viewDistance = 15.f;
break;
default:
viewDistance = 4.f;
}
auto target = world->pedestrianPool.find(world->state->cameraTarget);
if( target == nullptr )
{
target = player->getCharacter();
}
glm::vec3 targetPosition = target->getPosition();
glm::vec3 lookTargetPosition = targetPosition;
targetPosition += glm::vec3(0.f, 0.f, 1.f);
lookTargetPosition += glm::vec3(0.f, 0.f, 0.5f);
btCollisionObject* physTarget = player->getCharacter()->physObject;
auto vehicle = ( target->type() == GameObject::Character ) ? static_cast<CharacterObject*>(target)->getCurrentVehicle() : nullptr;
if( vehicle ) {
auto model = vehicle->model;
float maxDist = 0.f;
for(auto& g : model->resource->geometries) {
float partSize = glm::length(g->geometryBounds.center) + g->geometryBounds.radius;
maxDist = std::max(partSize, maxDist);
}
viewDistance = viewDistance + maxDist;
targetPosition = vehicle->getPosition();
lookTargetPosition = targetPosition;
lookTargetPosition.z += (vehicle->info->handling.dimensions.z * 0.5f);
targetPosition.z += (vehicle->info->handling.dimensions.z * 0.5f);
physTarget = vehicle->collision->getBulletBody();
if (!m_vehicleFreeLook)
{
m_cameraAngles.y = kVehicleCameraPitch;
}
// Rotate the camera to the ideal angle if the player isn't moving it
float velocity = vehicle->getVelocity();
if (autolookTimer <= 0.f && glm::abs(velocity) > kAutolookMinVelocity)
{
auto idealYaw = -glm::roll(vehicle->getRotation()) + glm::half_pi<float>();
const auto idealPitch = kVehicleCameraPitch;
if (velocity < 0.f) {
idealYaw = glm::mod(idealYaw - glm::pi<float>(), glm::pi<float>() * 2.f);
}
float currentYaw = glm::mod(m_cameraAngles.x, glm::pi<float>()*2);
float currentPitch = m_cameraAngles.y;
float deltaYaw = idealYaw - currentYaw;
float deltaPitch = idealPitch - currentPitch;
if (glm::abs(deltaYaw) > glm::pi<float>()) {
deltaYaw -= glm::sign(deltaYaw) * glm::pi<float>()*2.f;
}
m_cameraAngles.x += glm::sign(deltaYaw) * std::min(kMaxRotationRate * dt, glm::abs(deltaYaw));
m_cameraAngles.y += glm::sign(deltaPitch) * std::min(kMaxRotationRate * dt, glm::abs(deltaPitch));
}
}
// Non-topdown camera can orbit
if( camMode != IngameState::CAMERA_TOPDOWN )
{
bool lookleft = input.pressed(GameInputState::LookLeft);
bool lookright = input.pressed(GameInputState::LookRight);
if ((lookleft || lookright) && vehicle != nullptr) {
auto rotation = vehicle->getRotation();
if (! lookright) {
rotation *= glm::angleAxis(glm::half_pi<float>(), glm::vec3(0.f, 0.f,-1.f));
}
else if (! lookleft) {
rotation *= glm::angleAxis(glm::half_pi<float>(), glm::vec3(0.f, 0.f, 1.f));
}
cameraPosition = targetPosition + rotation * glm::vec3(0.f, viewDistance, 0.f);
}
else {
// Determine the "ideal" camera position for the current view
// angles
auto yaw =
glm::angleAxis(m_cameraAngles.x, glm::vec3(0.f, 0.f, -1.f));
auto pitch =
glm::angleAxis(m_cameraAngles.y, glm::vec3(0.f, 1.f, 0.f));
auto cameraOffset =
yaw * pitch * glm::vec3(0.f, 0.f, viewDistance);
cameraPosition = targetPosition + cameraOffset;
}
}
else
{
cameraPosition = targetPosition + glm::vec3(0.f, 0.f, viewDistance);
}
glm::quat angle;
auto camtotarget = targetPosition - cameraPosition;
auto dir = glm::normalize(camtotarget);
float correction = glm::length(camtotarget) - viewDistance;
if( correction < 0.f )
{
float innerDist = viewDistance * 0.1f;
correction = glm::min(0.f, correction + innerDist);
}
cameraPosition += dir * 10.f * correction * dt;
auto lookdir = glm::normalize(lookTargetPosition - cameraPosition);
// Calculate the yaw to look at the target.
float angleYaw = glm::atan(lookdir.y, lookdir.x);
angle = glm::quat( glm::vec3(0.f, 0.f, angleYaw) );
glm::vec3 movement;
movement.x = input[GameInputState::GoForward] - input[GameInputState::GoBackwards];
movement.y = input[GameInputState::GoLeft] - input[GameInputState::GoRight];
/// @todo replace with correct sprint behaviour
float speed = input.pressed(GameInputState::Sprint) ? 2.f : 1.f;
if( player->isInputEnabled() )
{
player->setRunning(!input.pressed(GameInputState::Walk));
/// @todo find the correct behaviour for entering & exiting
if (input.pressed(GameInputState::EnterExitVehicle)) {
/// @todo move me
if (player->getCharacter()->getCurrentVehicle()) {
player->exitVehicle();
}
else if (!player->isCurrentActivity(
Activities::EnterVehicle::ActivityName)) {
player->enterNearestVehicle();
}
}
else if (glm::length2(movement) > 0.001f) {
if (player->isCurrentActivity(
Activities::EnterVehicle::ActivityName)) {
// Give up entering a vehicle if we're alreadying doing so
player->skipActivity();
}
}
if (player->getCharacter()->getCurrentVehicle())
{
auto vehicle = player->getCharacter()->getCurrentVehicle();
vehicle->setHandbraking(input.pressed(GameInputState::Handbrake));
player->setMoveDirection(movement);
}
else
{
if (input.pressed(GameInputState::Jump)) {
player->jump();
}
float length = glm::length(movement);
float movementAngle = angleYaw - glm::half_pi<float>();
if (length > 0.1f)
{
glm::vec3 direction = glm::normalize(movement);
movementAngle += atan2(direction.y, direction.x);
player->setMoveDirection(glm::vec3(speed, 0.f, 0.f));
}
else
{
player->setMoveDirection(glm::vec3(0.f));
}
player->setLookDirection({movementAngle, 0.f});
}
}
else
{
player->setMoveDirection(glm::vec3(0.f));
}
float len2d = glm::length(glm::vec2(lookdir));
float anglePitch = glm::atan(lookdir.z, len2d);
angle *= glm::quat( glm::vec3(0.f, -anglePitch, 0.f) );
// Use rays to ensure target is visible from cameraPosition
auto rayEnd = cameraPosition;
auto rayStart = targetPosition;
auto to = btVector3(rayEnd.x, rayEnd.y, rayEnd.z);
auto from = btVector3(rayStart.x, rayStart.y, rayStart.z);
ClosestNotMeRayResultCallback ray(physTarget, from, to);
world->dynamicsWorld->rayTest(from, to, ray);
if( ray.hasHit() && ray.m_closestHitFraction < 1.f )
{
cameraPosition = glm::vec3(ray.m_hitPointWorld.x(), ray.m_hitPointWorld.y(),
ray.m_hitPointWorld.z());
cameraPosition += glm::vec3(ray.m_hitNormalWorld.x(), ray.m_hitNormalWorld.y(),
ray.m_hitNormalWorld.z()) * 0.1f;
}
_look.position = cameraPosition;
_look.rotation = angle;
}
}
void IngameState::draw(GameRenderer* r)
{
if( !getWorld()->state->isCinematic && getWorld()->isCutsceneDone() )
{
drawHUD(_look, game->getPlayer(), getWorld(), r);
}
State::draw(r);
}
void IngameState::handleEvent(const SDL_Event& event)
{
auto player = game->getPlayer();
switch(event.type) {
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_ESCAPE:
StateManager::get().enter(new PauseState(game));
break;
case SDLK_m:
StateManager::get().enter(new DebugState(game, _look.position, _look.rotation));
break;
case SDLK_SPACE:
if( getWorld()->state->currentCutscene )
{
getWorld()->state->skipCutscene = true;
}
break;
case SDLK_c:
camMode = CameraMode((camMode+(CameraMode)1)%CAMERA_MAX);
break;
default: break;
}
break;
default: break;
}
updateInputState(event);
if( player && player->isInputEnabled() )
{
handlePlayerInput(event);
}
State::handleEvent(event);
}
void IngameState::handlePlayerInput(const SDL_Event& event)
{
auto player = game->getPlayer();
switch(event.type) {
case SDL_MOUSEBUTTONDOWN:
switch(event.button.button) {
case SDL_BUTTON_LEFT:
player->getCharacter()->useItem(true, true);
break;
default: break;
}
break;
case SDL_MOUSEBUTTONUP:
switch(event.button.button) {
case SDL_BUTTON_LEFT:
player->getCharacter()->useItem(false, true);
break;
default: break;
}
break;
case SDL_MOUSEWHEEL:
player->getCharacter()->cycleInventory(event.wheel.y > 0);
break;
case SDL_MOUSEMOTION:
if (game->hasFocus())
{
glm::ivec2 screenSize = getWindow().getSize();
glm::vec2 mouseMove(event.motion.xrel / static_cast<float>(screenSize.x),
event.motion.yrel / static_cast<float>(screenSize.y));
autolookTimer = kAutoLookTime;
if (!m_invertedY) {
mouseMove.y = -mouseMove.y;
}
m_cameraAngles += glm::vec2(mouseMove.x, mouseMove.y);
m_cameraAngles.y = glm::clamp(m_cameraAngles.y, kCameraPitchLimit, glm::pi<float>() - kCameraPitchLimit);
}
break;
default:
break;
}
}
void IngameState::updateInputState(const SDL_Event& event)
{
switch (event.type) {
case SDL_KEYDOWN:
case SDL_KEYUP: {
auto sym = event.key.keysym.sym;
auto level = event.type == SDL_KEYDOWN ? 1.f : 0.f;
auto& levels = getWorld()->state->input.currentLevels;
auto range = kDefaultControls.equal_range(sym);
for (auto it = range.first; it != range.second; ++it) {
levels[it->second] = level;
}
} break;
}
}
bool IngameState::shouldWorldUpdate()
{
return true;
}
const ViewCamera &IngameState::getCamera()
{
return _look;
}
View Git Blame Copy Permalink