X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fobject%2Fcamera.cpp;h=abca4a7e68b3e47f3c166143ea6c689ef3fc1b4b;hb=7532d474f5a450576181138b577cb9328d8d802c;hp=5153dff3ecec204ec964f499384612987e7a156e;hpb=be3c510caa2d780caa0e6d817c98637fbe4bb376;p=supertux.git diff --git a/src/object/camera.cpp b/src/object/camera.cpp index 5153dff3e..abca4a7e6 100644 --- a/src/object/camera.cpp +++ b/src/object/camera.cpp @@ -1,12 +1,10 @@ -// $Id$ -// // SuperTux // Copyright (C) 2006 Matthias Braun // -// 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 2 -// of the License, or (at your option) any later version. +// 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 @@ -14,45 +12,43 @@ // 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, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -#include +// along with this program. If not, see . + +#include "object/camera.hpp" -#include -#include -#include +#include +#include -#include "lisp/lisp.hpp" -#include "lisp/writer.hpp" -#include "lisp/list_iterator.hpp" +#include "util/reader.hpp" +#include "util/writer.hpp" #include "lisp/parser.hpp" +#include "object/path_walker.hpp" +#include "object/player.hpp" #include "scripting/camera.hpp" #include "scripting/squirrel_util.hpp" -#include "camera.hpp" -#include "player.hpp" -#include "tilemap.hpp" -#include "game_session.hpp" -#include "sector.hpp" -#include "main.hpp" -#include "object_factory.hpp" -#include "log.hpp" -#include "path.hpp" -#include "path_walker.hpp" +#include "supertux/globals.hpp" +#include "supertux/sector.hpp" + +/* this is the fractional distance toward the peek + position to move each frame; lower is slower, + 0 is never get there, 1 is instant */ +static const float PEEK_ARRIVE_RATIO = 0.1; class CameraConfig { public: - // 0 = No, 1 = Fix, 2 = Mario/Yoshi, 3 = Kirby, 4 = inverse rubber - int ymode; + // 0 = No, 1 = Fix, 2 = Mario/Yoshi, 3 = Kirby, 4 = Super Metroid-like int xmode; + // as above + int ymode; float kirby_rectsize_x; float kirby_rectsize_y; // where to fix the player (used for Yoshi and Fix camera) - float target_y; float target_x; + float target_y; // maximum scrolling speed in Y direction - float max_speed_y; float max_speed_x; + float max_speed_y; // factor to dynamically increase max_speed_x based on player speed float dynamic_max_speed_x; @@ -65,24 +61,28 @@ public: // set to <= 0 to disable noscroll mode float sensitive_x; - float clamp_y; float clamp_x; + float clamp_y; - CameraConfig() { - xmode = 1; - ymode = 1; - target_x = .5f; - target_y = 2.f/3.f; - max_speed_y = 140; - max_speed_x = 130; - clamp_x = 1.f/6.f; - clamp_y = 1.f/6.f; - kirby_rectsize_x = 0.2f; - kirby_rectsize_y = 0.34f; - edge_x = 1.f/3.f; - sensitive_x = 1.f/4.f; - dynamic_max_speed_x = 1.0; - dirchange_time = 0.2f; + float dynamic_speed_sm; + + CameraConfig() : + xmode(4), + ymode(3), + kirby_rectsize_x(0.2f), + kirby_rectsize_y(0.34f), + target_x(.5f), + target_y(.5f), + max_speed_x(100), + max_speed_y(100), + dynamic_max_speed_x(1.0), + dirchange_time(0.2f), + edge_x(0.4f), + sensitive_x(-1), + clamp_x(0.1666f), + clamp_y(0.3f), + dynamic_speed_sm(0.8f) + { } void load(const std::string& filename) @@ -107,13 +107,32 @@ public: camconfig->get("kirby-rectsize-y", kirby_rectsize_y); camconfig->get("edge-x", edge_x); camconfig->get("sensitive-x", sensitive_x); + camconfig->get("dynamic-speed-sm", dynamic_speed_sm); } }; -Camera::Camera(Sector* newsector, std::string name) - : mode(NORMAL), sector(newsector), lookahead_mode(LOOKAHEAD_NONE) +Camera::Camera(Sector* newsector, std::string name_) : + mode(NORMAL), + translation(), + sector(newsector), + lookahead_mode(LOOKAHEAD_NONE), + changetime(), + lookahead_pos(), + peek_pos(), + cached_translation(), + autoscroll_path(), + autoscroll_walker(), + shaketimer(), + shakespeed(), + shakedepth_x(), + shakedepth_y(), + scroll_from(), + scroll_goal(), + scroll_to_pos(), + scrollspeed(), + config() { - this->name = name; + this->name = name_; config = new CameraConfig(); reload_config(); } @@ -127,15 +146,15 @@ void Camera::expose(HSQUIRRELVM vm, SQInteger table_idx) { if(name.empty()) return; - Scripting::Camera* interface = new Scripting::Camera(this); - expose_object(vm, table_idx, interface, name, true); + scripting::Camera* _this = new scripting::Camera(this); + expose_object(vm, table_idx, _this, name, true); } void Camera::unexpose(HSQUIRRELVM vm, SQInteger table_idx) { if(name.empty()) return; - Scripting::unexpose_object(vm, table_idx, name); + scripting::unexpose_object(vm, table_idx, name); } void @@ -150,7 +169,7 @@ Camera::get_translation() const } void -Camera::parse(const lisp::Lisp& reader) +Camera::parse(const Reader& reader) { std::string modename; @@ -177,30 +196,16 @@ Camera::parse(const lisp::Lisp& reader) } void -Camera::write(lisp::Writer& writer) -{ - writer.start_list("camera"); - - if(mode == NORMAL) { - writer.write_string("mode", "normal"); - } else if(mode == AUTOSCROLL) { - writer.write_string("mode", "autoscroll"); - autoscroll_path->write(writer); - } else if(mode == MANUAL) { - writer.write_string("mode", "manual"); - } - - writer.end_list("camera"); -} - -void Camera::reset(const Vector& tuxpos) { - translation.x = tuxpos.x - SCREEN_WIDTH/3 * 2; + translation.x = tuxpos.x - SCREEN_WIDTH/2; translation.y = tuxpos.y - SCREEN_HEIGHT/2; + shakespeed = 0; shaketimer.stop(); keep_in_bounds(translation); + + cached_translation = translation; } void @@ -224,7 +229,7 @@ Camera::scroll_to(const Vector& goal, float scrolltime) mode = SCROLLTO; } -static const float EPSILON = .00001f; +static const float CAMERA_EPSILON = .00001f; static const float MAX_SPEED_Y = 140; void @@ -249,7 +254,15 @@ Camera::update(float elapsed_time) void Camera::reload_config() { - config->load("camera.cfg"); + if(PHYSFS_exists("camera.cfg")) { + try { + config->load("camera.cfg"); + log_info << "Loaded camera.cfg." << std::endl; + } catch(std::exception &e) { + log_debug << "Couldn't load camera.cfg, using defaults (" + << e.what() << ")" << std::endl; + } + } } float clamp(float val, float min, float max) @@ -263,19 +276,19 @@ float clamp(float val, float min, float max) } void -Camera::keep_in_bounds(Vector& translation) +Camera::keep_in_bounds(Vector& translation_) { float width = sector->get_width(); float height = sector->get_height(); // don't scroll before the start or after the level's end - translation.x = clamp(translation.x, 0, width - SCREEN_WIDTH); - translation.y = clamp(translation.y, 0, height - SCREEN_HEIGHT); + translation_.x = clamp(translation_.x, 0, width - SCREEN_WIDTH); + translation_.y = clamp(translation_.y, 0, height - SCREEN_HEIGHT); if (height < SCREEN_HEIGHT) - translation.y = height/2.0 - SCREEN_HEIGHT/2.0; + translation_.y = height/2.0 - SCREEN_HEIGHT/2.0; if (width < SCREEN_WIDTH) - translation.x = width/2.0 - SCREEN_WIDTH/2.0; + translation_.x = width/2.0 - SCREEN_WIDTH/2.0; } void @@ -290,28 +303,27 @@ Camera::shake() void Camera::update_scroll_normal(float elapsed_time) { - const CameraConfig& config = *(this->config); + const CameraConfig& config_ = *(this->config); Player* player = sector->player; - const Vector& player_pos = player->get_bbox().get_middle(); + // TODO: co-op mode needs a good camera + Vector player_pos(player->get_bbox().get_middle().x, + player->get_bbox().get_bottom()); static Vector last_player_pos = player_pos; Vector player_delta = player_pos - last_player_pos; last_player_pos = player_pos; // check that we don't have division by zero later - if(elapsed_time < EPSILON) + if(elapsed_time < CAMERA_EPSILON) return; /****** Vertical Scrolling part ******/ - int xmode = config.xmode; - int ymode = config.ymode; + int ymode = config_.ymode; if(player->is_dying() || sector->get_height() == 19*32) { ymode = 0; - xmode = 0; } - if(ymode == 1) { - translation.y = player_pos.y - SCREEN_HEIGHT * config.target_y; + cached_translation.y = player_pos.y - SCREEN_HEIGHT * config_.target_y; } if(ymode == 2) { // target_y is the high we target our scrolling at. This is not always the @@ -319,50 +331,110 @@ Camera::update_scroll_normal(float elapsed_time) // position where he last touched the ground. (this probably needs // exceptions for trampolines and similar things in the future) float target_y; -#if 0 if(player->fall_mode == Player::JUMPING) target_y = player->last_ground_y + player->get_bbox().get_height(); else target_y = player->get_bbox().p2.y; -#endif - target_y = player->last_ground_y; - - target_y -= SCREEN_HEIGHT * config.target_y; + target_y -= SCREEN_HEIGHT * config_.target_y; // delta_y is the distance we'd have to travel to directly reach target_y - float delta_y = translation.y - target_y; + float delta_y = cached_translation.y - target_y; // speed is the speed the camera would need to reach target_y in this frame float speed_y = delta_y / elapsed_time; // limit the camera speed when jumping upwards if(player->fall_mode != Player::FALLING - && player->fall_mode != Player::TRAMPOLINE_JUMP) { - speed_y = clamp(speed_y, -config.max_speed_y, config.max_speed_y); + && player->fall_mode != Player::TRAMPOLINE_JUMP) { + speed_y = clamp(speed_y, -config_.max_speed_y, config_.max_speed_y); } // scroll with calculated speed - translation.y -= speed_y * elapsed_time; + cached_translation.y -= speed_y * elapsed_time; } if(ymode == 3) { - float halfsize = config.kirby_rectsize_y * 0.5f; - translation.y = clamp(translation.y, - player_pos.y - SCREEN_HEIGHT * (0.5f + halfsize), - player_pos.y - SCREEN_HEIGHT * (0.5f - halfsize)); + float halfsize = config_.kirby_rectsize_y * 0.5f; + cached_translation.y = clamp(cached_translation.y, + player_pos.y - SCREEN_HEIGHT * (0.5f + halfsize), + player_pos.y - SCREEN_HEIGHT * (0.5f - halfsize)); } if(ymode == 4) { - // TODO... + float upperend = SCREEN_HEIGHT * config_.edge_x; + float lowerend = SCREEN_HEIGHT * (1 - config_.edge_x); + + if (player_delta.y < -CAMERA_EPSILON) { + // walking left + lookahead_pos.y -= player_delta.y * config_.dynamic_speed_sm; + + if(lookahead_pos.y > lowerend) { + lookahead_pos.y = lowerend; + } + } else if (player_delta.y > CAMERA_EPSILON) { + // walking right + lookahead_pos.y -= player_delta.y * config_.dynamic_speed_sm; + if(lookahead_pos.y < upperend) { + lookahead_pos.y = upperend; + } + } + + // adjust for level ends + if (player_pos.y < upperend) { + lookahead_pos.y = upperend; + } + if (player_pos.y > sector->get_width() - upperend) { + lookahead_pos.y = lowerend; + } + + cached_translation.y = player_pos.y - lookahead_pos.y; } - if(ymode != 0 && config.clamp_y > 0) { - translation.y = clamp(translation.y, - player_pos.y - SCREEN_HEIGHT * (1-config.clamp_y), - player_pos.y - SCREEN_HEIGHT * config.clamp_y); + translation.y = cached_translation.y; + + if(ymode != 0) { + float top_edge, bottom_edge; + if(config_.clamp_y <= 0) { + top_edge = 0; + bottom_edge = SCREEN_HEIGHT; + } else { + top_edge = SCREEN_HEIGHT*config_.clamp_y; + bottom_edge = SCREEN_HEIGHT*(1-config_.clamp_y); + } + + float peek_to = 0; + float translation_compensation = player_pos.y - translation.y; + + if(player->peeking_direction_y() == ::UP) { + peek_to = bottom_edge - translation_compensation; + } else if(player->peeking_direction_y() == ::DOWN) { + peek_to = top_edge - translation_compensation; + } + + float peek_move = (peek_to - peek_pos.y) * PEEK_ARRIVE_RATIO; + if(fabs(peek_move) < 1.0) { + peek_move = 0.0; + } + + peek_pos.y += peek_move; + + translation.y -= peek_pos.y; + + if(config_.clamp_y > 0) { + translation.y = clamp(translation.y, + player_pos.y - SCREEN_HEIGHT * (1-config_.clamp_y), + player_pos.y - SCREEN_HEIGHT * config_.clamp_y); + cached_translation.y = clamp(cached_translation.y, + player_pos.y - SCREEN_HEIGHT * (1-config_.clamp_y), + player_pos.y - SCREEN_HEIGHT * config_.clamp_y); + } } /****** Horizontal scrolling part *******/ + int xmode = config_.xmode; + + if(player->is_dying()) + xmode = 0; if(xmode == 1) { - translation.x = player_pos.x - SCREEN_WIDTH * config.target_x; + cached_translation.x = player_pos.x - SCREEN_WIDTH * config_.target_x; } if(xmode == 2) { // our camera is either in leftscrolling, rightscrolling or @@ -374,15 +446,15 @@ Camera::update_scroll_normal(float elapsed_time) // Find out direction in which the player moves LookaheadMode walkDirection; - if (player_delta.x < -EPSILON) walkDirection = LOOKAHEAD_LEFT; - else if (player_delta.x > EPSILON) walkDirection = LOOKAHEAD_RIGHT; + if (player_delta.x < -CAMERA_EPSILON) walkDirection = LOOKAHEAD_LEFT; + else if (player_delta.x > CAMERA_EPSILON) walkDirection = LOOKAHEAD_RIGHT; else if (player->dir == ::LEFT) walkDirection = LOOKAHEAD_LEFT; else walkDirection = LOOKAHEAD_RIGHT; float LEFTEND, RIGHTEND; - if(config.sensitive_x > 0) { - LEFTEND = SCREEN_WIDTH * config.sensitive_x; - RIGHTEND = SCREEN_WIDTH * (1-config.sensitive_x); + if(config_.sensitive_x > 0) { + LEFTEND = SCREEN_WIDTH * config_.sensitive_x; + RIGHTEND = SCREEN_WIDTH * (1-config_.sensitive_x); } else { LEFTEND = SCREEN_WIDTH; RIGHTEND = 0; @@ -391,9 +463,9 @@ Camera::update_scroll_normal(float elapsed_time) if(lookahead_mode == LOOKAHEAD_NONE) { /* if we're undecided then look if we crossed the left or right * "sensitive" area */ - if(player_pos.x < translation.x + LEFTEND) { + if(player_pos.x < cached_translation.x + LEFTEND) { lookahead_mode = LOOKAHEAD_LEFT; - } else if(player_pos.x > translation.x + RIGHTEND) { + } else if(player_pos.x > cached_translation.x + RIGHTEND) { lookahead_mode = LOOKAHEAD_RIGHT; } /* at the ends of a level it's obvious which way we will go */ @@ -410,12 +482,12 @@ Camera::update_scroll_normal(float elapsed_time) * sudden changes */ if(changetime < 0) { changetime = game_time; - } else if(game_time - changetime > config.dirchange_time) { + } else if(game_time - changetime > config_.dirchange_time) { if(lookahead_mode == LOOKAHEAD_LEFT && - player_pos.x > translation.x + RIGHTEND) { + player_pos.x > cached_translation.x + RIGHTEND) { lookahead_mode = LOOKAHEAD_RIGHT; } else if(lookahead_mode == LOOKAHEAD_RIGHT && - player_pos.x < translation.x + LEFTEND) { + player_pos.x < cached_translation.x + LEFTEND) { lookahead_mode = LOOKAHEAD_LEFT; } else { lookahead_mode = LOOKAHEAD_NONE; @@ -425,8 +497,8 @@ Camera::update_scroll_normal(float elapsed_time) changetime = -1; } - LEFTEND = SCREEN_WIDTH * config.edge_x; - RIGHTEND = SCREEN_WIDTH * (1-config.edge_x); + LEFTEND = SCREEN_WIDTH * config_.edge_x; + RIGHTEND = SCREEN_WIDTH * (1-config_.edge_x); // calculate our scroll target depending on scroll mode float target_x; @@ -435,46 +507,100 @@ Camera::update_scroll_normal(float elapsed_time) else if(lookahead_mode == LOOKAHEAD_RIGHT) target_x = player_pos.x - LEFTEND; else - target_x = translation.x; + target_x = cached_translation.x; // that's the distance we would have to travel to reach target_x - float delta_x = translation.x - target_x; + float delta_x = cached_translation.x - target_x; // the speed we'd need to travel to reach target_x in this frame float speed_x = delta_x / elapsed_time; // limit our speed float player_speed_x = player_delta.x / elapsed_time; - float maxv = config.max_speed_x + (fabsf(player_speed_x * config.dynamic_max_speed_x)); + float maxv = config_.max_speed_x + (fabsf(player_speed_x * config_.dynamic_max_speed_x)); speed_x = clamp(speed_x, -maxv, maxv); - // If player is peeking scroll in that direction. Fast. - if(player->peeking_direction() == ::LEFT) { - speed_x = config.max_speed_x; - } - if(player->peeking_direction() == ::RIGHT) { - speed_x = -config.max_speed_x; - } - // apply scrolling - translation.x -= speed_x * elapsed_time; + cached_translation.x -= speed_x * elapsed_time; } - if(mode == 3) { - float halfsize = config.kirby_rectsize_x * 0.5f; - translation.x = clamp(translation.x, - player_pos.x - SCREEN_WIDTH * (0.5f + halfsize), - player_pos.x - SCREEN_WIDTH * (0.5f - halfsize)); + if(xmode == 3) { + float halfsize = config_.kirby_rectsize_x * 0.5f; + cached_translation.x = clamp(cached_translation.x, + player_pos.x - SCREEN_WIDTH * (0.5f + halfsize), + player_pos.x - SCREEN_WIDTH * (0.5f - halfsize)); } if(xmode == 4) { - // TODO... + float LEFTEND = SCREEN_WIDTH * config_.edge_x; + float RIGHTEND = SCREEN_WIDTH * (1 - config_.edge_x); + + if (player_delta.x < -CAMERA_EPSILON) { + // walking left + lookahead_pos.x -= player_delta.x * config_.dynamic_speed_sm; + if(lookahead_pos.x > RIGHTEND) { + lookahead_pos.x = RIGHTEND; + } + + } else if (player_delta.x > CAMERA_EPSILON) { + // walking right + lookahead_pos.x -= player_delta.x * config_.dynamic_speed_sm; + if(lookahead_pos.x < LEFTEND) { + lookahead_pos.x = LEFTEND; + } + } + + // adjust for level ends + if (player_pos.x < LEFTEND) { + lookahead_pos.x = LEFTEND; + } + if (player_pos.x > sector->get_width() - LEFTEND) { + lookahead_pos.x = RIGHTEND; + } + + cached_translation.x = player_pos.x - lookahead_pos.x; } - if(xmode != 0 && config.clamp_x > 0) { - translation.x = clamp(translation.x, - player_pos.x - SCREEN_WIDTH * (1-config.clamp_x), - player_pos.x - SCREEN_WIDTH * config.clamp_x); + translation.x = cached_translation.x; + + if(xmode != 0) { + float left_edge, right_edge; + if(config_.clamp_x <= 0) { + left_edge = 0; + right_edge = SCREEN_WIDTH; + } else { + left_edge = SCREEN_WIDTH*config_.clamp_x; + right_edge = SCREEN_WIDTH*(1-config_.clamp_x); + } + + float peek_to = 0; + float translation_compensation = player_pos.x - translation.x; + + if(player->peeking_direction_x() == ::LEFT) { + peek_to = right_edge - translation_compensation; + } else if(player->peeking_direction_x() == ::RIGHT) { + peek_to = left_edge - translation_compensation; + } + + float peek_move = (peek_to - peek_pos.x) * PEEK_ARRIVE_RATIO; + if(fabs(peek_move) < 1.0) { + peek_move = 0.0; + } + + peek_pos.x += peek_move; + + translation.x -= peek_pos.x; + + if(config_.clamp_x > 0) { + translation.x = clamp(translation.x, + player_pos.x - SCREEN_WIDTH * (1-config_.clamp_x), + player_pos.x - SCREEN_WIDTH * config_.clamp_x); + + cached_translation.x = clamp(cached_translation.x, + player_pos.x - SCREEN_WIDTH * (1-config_.clamp_x), + player_pos.x - SCREEN_WIDTH * config_.clamp_x); + } } keep_in_bounds(translation); + keep_in_bounds(cached_translation); } void @@ -501,3 +627,10 @@ Camera::update_scroll_to(float elapsed_time) translation = scroll_from + (scroll_goal - scroll_from) * scroll_to_pos; } + +Vector +Camera::get_center() const { + return translation + Vector(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2); +} + +/* EOF */