From: Matthias Braun Date: Sat, 3 Mar 2007 17:12:34 +0000 (+0000) Subject: experimental code to influence camera, adjusted some parameters, tried to improve... X-Git-Url: https://git.verplant.org/?a=commitdiff_plain;h=bfb1843f48afe90512ac90b4f4b8451f1f0e1d18;p=supertux.git experimental code to influence camera, adjusted some parameters, tried to improve camera parameters SVN-Revision: 4913 --- diff --git a/data/camera.cfg b/data/camera.cfg new file mode 100644 index 000000000..a8d9a70b3 --- /dev/null +++ b/data/camera.cfg @@ -0,0 +1,40 @@ +(camera-config + ; Note that most coordinates are given as fractions of SCREEN_WIDTH + ; and SCREEN_HEIGHT, so .5 in -x and -y means in the middle of the screen + ; 0.3 in x and .66 in y means in left 1/3rd of the screen at the upper 2/3rd + ; (which is the lower 1/3rd) of the screen... + + ; 0 = No, 1 = Fix, 2 = Mario/Yoshi, 3 = Kirby, 4 = inverse rubberband + (xmode 2) + ; 0 = No, 1 = Fix, 2 = Mario/Yoshi, 3 = Kirby, 4 = inverse rubberband + (ymode 2) + + ; Specify the size of the midle rect of kirby camera mode + (kirby-rectsize-x 0.2) + (kirby-rectsize-y 0.34) + + ; Specify where to keep tux in fixed camera mode + (target-x 0.5) + (target-y 0.5) + + ; Speed is limited to these for the Yoshi cam + (max-speed-x 50) + (max-speed-y 140) + + ; Used in YI camera to adjust to max_speed relatively to player speed + (dynamic-max-speed-x 1.0) + + ; Make sure tux never leaves the clamp area on screen (works for all + ; cameras, can be disabled by setting it to 0) + ;(clamp-x .1666) + ;(clamp-y .1666) + (clamp-x 0) + (clamp-y 0) + + ; Keep tux here when he runs in YI mode + (edge-x 0.3) + ; If YI camera is in no-scrollmode it will go to scrollmode again if tux + ; reaches this part of the screen + (sensitive-x 0.4) +) + diff --git a/src/object/camera.cpp b/src/object/camera.cpp index e4fd50ae7..25a2d921e 100644 --- a/src/object/camera.cpp +++ b/src/object/camera.cpp @@ -25,6 +25,7 @@ #include "lisp/lisp.hpp" #include "lisp/writer.hpp" #include "lisp/list_iterator.hpp" +#include "lisp/parser.hpp" #include "scripting/camera.hpp" #include "scripting/squirrel_util.hpp" #include "camera.hpp" @@ -40,18 +41,83 @@ namespace { enum CameraStyle { CameraStyleYI, CameraStyleKD, CameraStyleEXP }; - const CameraStyle cameraStyle = CameraStyleYI; + const CameraStyle cameraStyle = CameraStyleEXP; } +class CameraConfig +{ +public: + // 0 = No, 1 = Fix, 2 = Mario/Yoshi, 3 = Kirby, 4 = inverse rubber + int ymode; + int xmode; + 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; + // maximum scrolling speed in Y direction + float max_speed_y; + float max_speed_x; + // factor to dynamically increase max_speed_x based on player speed + float dynamic_max_speed_x; + // edge_x + float edge_x; + float sensitive_x; + + float clamp_y; + float clamp_x; + + 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; + } + + void load(const std::string& filename) + { + lisp::Parser parser; + const lisp::Lisp* root = parser.parse(filename); + const lisp::Lisp* camconfig = root->get_lisp("camera-config"); + if(camconfig == NULL) + throw std::runtime_error("file is not a camera config file."); + + camconfig->get("xmode", xmode); + camconfig->get("ymode", ymode); + camconfig->get("target-x", target_x); + camconfig->get("target-y", target_y); + camconfig->get("max-speed-x", max_speed_x); + camconfig->get("max-speed-y", max_speed_y); + camconfig->get("dynamic-max-speed-x", dynamic_max_speed_x); + camconfig->get("clamp-x", clamp_x); + camconfig->get("clamp-y", clamp_y); + camconfig->get("kirby-rectsize-x", kirby_rectsize_x); + camconfig->get("kirby-rectsize-y", kirby_rectsize_y); + camconfig->get("edge-x", edge_x); + camconfig->get("sensitive-x", sensitive_x); + } +}; + Camera::Camera(Sector* newsector, std::string name) - : mode(NORMAL), sector(newsector), do_backscrolling(true), - scrollchange(NONE) + : mode(NORMAL), sector(newsector), scrollchange(NONE) { this->name = name; + config = new CameraConfig(); + reload_config(); } Camera::~Camera() { + delete config; } void @@ -69,6 +135,11 @@ Camera::unexpose(HSQUIRRELVM vm, SQInteger table_idx) Scripting::unexpose_object(vm, table_idx, name); } +void +Camera::draw(DrawingContext& ) +{ +} + const Vector& Camera::get_translation() const { @@ -83,9 +154,6 @@ Camera::parse(const lisp::Lisp& reader) reader.get("mode", modename); if(modename == "normal") { mode = NORMAL; - - do_backscrolling = true; - reader.get("backscrolling", do_backscrolling); } else if(modename == "autoscroll") { mode = AUTOSCROLL; @@ -112,7 +180,6 @@ Camera::write(lisp::Writer& writer) if(mode == NORMAL) { writer.write_string("mode", "normal"); - writer.write_bool("backscrolling", do_backscrolling); } else if(mode == AUTOSCROLL) { writer.write_string("mode", "autoscroll"); autoscroll_path->write(writer); @@ -172,7 +239,7 @@ Camera::scroll_to(const Vector& goal, float scrolltime) } static const float EPSILON = .00001f; -static const float max_speed_y = 140; +static const float MAX_SPEED_Y = 140; void Camera::update(float elapsed_time) @@ -193,22 +260,33 @@ Camera::update(float elapsed_time) } void +Camera::reload_config() +{ + config->load("camera.cfg"); +} + +float clamp(float val, float min, float max) +{ + if(val < min) + return min; + if(val > max) + return max; + + return val; +} + +void 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 - if(translation.y > height - SCREEN_HEIGHT) - translation.y = height - SCREEN_HEIGHT; - if(translation.y < 0) - translation.y = 0; + 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; - if(translation.x > width - SCREEN_WIDTH) - translation.x = width - SCREEN_WIDTH; - if(translation.x < 0) - translation.x = 0; if (width < SCREEN_WIDTH) translation.x = width/2.0 - SCREEN_WIDTH/2.0; } @@ -226,32 +304,36 @@ void Camera::update_scroll_normal_kd(float elapsed_time) { // make sure some time has actually passed - if(elapsed_time < EPSILON) return; + if(elapsed_time < EPSILON) + return; // make sure we have an active player - assert(sector != 0); + assert(sector != NULL); Player* player = sector->player; Vector playerCenter = player->get_bbox().get_middle(); // If player is peeking, scroll in that direction if (player->peeking_direction() == ::LEFT) { - translation.x -= elapsed_time * 128.0f; - } - else if (player->peeking_direction() == ::RIGHT) { - translation.x += elapsed_time * 128.0f; + translation.x -= elapsed_time * 128.0f; + } else if (player->peeking_direction() == ::RIGHT) { + translation.x += elapsed_time * 128.0f; } // keep player within a small box, centered on the screen (vertical part) bool do_y_scrolling = true; - if (player->is_dying() || sector->get_height() == 19*32) do_y_scrolling = false; + if (player->is_dying() || sector->get_height() == 19*32) + do_y_scrolling = false; + if (do_y_scrolling) { - translation.y = std::min(player->get_bbox().p1.y - SCREEN_HEIGHT * (0.5f - 0.17f), translation.y); - translation.y = std::max(player->get_bbox().p2.y - SCREEN_HEIGHT * (0.5f + 0.17f), translation.y); + translation.y = clamp(translation.y, + player->get_bbox().p1.y - SCREEN_HEIGHT * (0.5f - 0.17f), + player->get_bbox().p2.y - SCREEN_HEIGHT * (0.5f + 0.17f)); } // keep player within a small box, centered on the screen (horizontal part) - translation.x = std::min(player->get_bbox().p1.x - SCREEN_WIDTH * (0.5f - 0.1f), translation.x); - translation.x = std::max(player->get_bbox().p2.x - SCREEN_WIDTH * (0.5f + 0.1f), translation.x); + translation.x = clamp(translation.x, + player->get_bbox().p1.x - SCREEN_WIDTH * (0.5f - 0.1f), + player->get_bbox().p2.x - SCREEN_WIDTH * (0.5f + 0.1f)); // make sure camera doesn't point outside level borders keep_in_bounds(translation); @@ -260,20 +342,156 @@ Camera::update_scroll_normal_kd(float elapsed_time) shake(); } -template -T clamp(T min, T max, T val) -{ - if(val < min) - return min; - if(val > max) - return max; - - return val; -} - void Camera::update_scroll_normal_exp(float elapsed_time) { + const CameraConfig& config = *(this->config); + Player* player = sector->player; + const Vector& player_pos = player->get_bbox().get_middle(); + static Vector last_player_pos = player_pos; + Vector player_delta = player_pos - last_player_pos; + + // check that we don't have division by zero later + if(elapsed_time < EPSILON) + return; + + /****** Vertical Scrolling part ******/ + int ymode = config.ymode; + + if(player->is_dying() || sector->get_height() == 19*32) { + ymode = 0; + } + + if(ymode == 1) { + 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 + // high of the player, but if he is jumping upwards we should use the + // position where he last touched the ground. (this probably needs + // exceptions for trampolines and similar things in the future) + float target_y; + 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; + 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; + // 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); + } + + // scroll with calculated speed + 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)); + } + if(ymode == 4) { + // TODO... + } + + if(ymode != 0 && config.clamp_y > 0) { + translation.y = clamp(translation.y, + player_pos.y - SCREEN_HEIGHT * config.clamp_y, + player_pos.y - SCREEN_HEIGHT * (1-config.clamp_y)); + } + + /****** Horizontal scrolling part *******/ + + if(config.xmode == 1) { + translation.x = player_pos.x - SCREEN_WIDTH * config.target_x; + } + if(config.xmode == 2) { + // our camera is either in leftscrolling, rightscrolling or + // nonscrollingmode. + // + // when suddenly changing directions while scrolling into the other + // direction abort scrolling, since tux might be going left/right at a + // relatively small part of the map (like when jumping upwards) + + // Find out direction in which the player walks + LeftRightScrollChange walkDirection; + if (player->physic.get_velocity_x() < -EPSILON) walkDirection = LEFT; + else if (player->physic.get_velocity_x() > EPSILON) walkDirection = RIGHT; + else if (player->dir == ::LEFT) walkDirection = LEFT; + else walkDirection = RIGHT; + + float LEFTEND = SCREEN_WIDTH * config.sensitive_x; + float RIGHTEND = SCREEN_WIDTH * (1-config.sensitive_x); + + if((walkDirection == LEFT && scrollchange == RIGHT) + || (walkDirection == RIGHT && scrollchange == LEFT)) + scrollchange = NONE; + // when in left 1/3rd of screen scroll left + if(player_pos.x < translation.x + LEFTEND) + scrollchange = LEFT; + // scroll right when in right 1/3rd of screen + else if(player_pos.x > translation.x + RIGHTEND) + scrollchange = RIGHT; + + LEFTEND = SCREEN_WIDTH * config.edge_x; + RIGHTEND = SCREEN_HEIGHT * (1- config.edge_x); + + // calculate our scroll target depending on scroll mode + float target_x; + if(scrollchange == LEFT) + target_x = player->get_bbox().get_middle().x - RIGHTEND; + else if(scrollchange == RIGHT) + target_x = player->get_bbox().get_middle().x - LEFTEND; + else + target_x = translation.x; + + // that's the distance we would have to travel to reach target_x + float delta_x = 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 maxv = config.max_speed_x + (fabsf(player->physic.get_velocity_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; + } + if(config.xmode == 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(config.xmode == 4) { + // TODO... + } + + if(config.xmode != 0 && config.clamp_x > 0) { + translation.x = clamp(translation.x, + player_pos.x - SCREEN_WIDTH * config.clamp_x, + player_pos.x - SCREEN_WIDTH * (1-config.clamp_x)); + } + + keep_in_bounds(translation); + shake(); + +#if 0 static const Vector camera_speed = Vector(300, 100); Player* player = sector->player; @@ -298,6 +516,7 @@ Camera::update_scroll_normal_exp(float elapsed_time) keep_in_bounds(translation); shake(); +#endif } void @@ -344,18 +563,16 @@ Camera::update_scroll_normal(float elapsed_time) // limit the camera speed when jumping upwards if(player->fall_mode != Player::FALLING && player->fall_mode != Player::TRAMPOLINE_JUMP) { - if(speed_y > max_speed_y) - speed_y = max_speed_y; - else if(speed_y < -max_speed_y) - speed_y = -max_speed_y; + speed_y = clamp(speed_y, -MAX_SPEED_Y, MAX_SPEED_Y); } // finally scroll with calculated speed translation.y -= speed_y * elapsed_time; // make sure to always keep the player inside the middle 1/6 of the screen - translation.y = std::min(player->get_bbox().p1.y - SCREEN_HEIGHT*1/6, translation.y); - translation.y = std::max(player->get_bbox().p2.y - SCREEN_HEIGHT*5/6, translation.y); + translation.y = clamp(translation.y, + player->get_bbox().p1.y - SCREEN_HEIGHT*1/6, + player->get_bbox().p2.y - SCREEN_HEIGHT*5/6); } /****** Horizontal scrolling part *******/ @@ -375,24 +592,26 @@ Camera::update_scroll_normal(float elapsed_time) else if (player->dir == ::LEFT) walkDirection = LEFT; else walkDirection = RIGHT; + static const float LEFTEND = SCREEN_WIDTH*2/5; + static const float RIGHTEND = SCREEN_WIDTH*4/5; if((walkDirection == LEFT && scrollchange == RIGHT) || (walkDirection == RIGHT && scrollchange == LEFT)) scrollchange = NONE; // when in left 1/3rd of screen scroll left - if(player->get_bbox().get_middle().x < translation.x + SCREEN_WIDTH/3 - 16 + if(player->get_bbox().get_middle().x < translation.x + LEFTEND - 16 && do_backscrolling) scrollchange = LEFT; // scroll right when in right 1/3rd of screen - else if(player->get_bbox().get_middle().x > translation.x + SCREEN_WIDTH/3*2+16) + else if(player->get_bbox().get_middle().x > translation.x + RIGHTEND + 16) scrollchange = RIGHT; // calculate our scroll target depending on scroll mode float target_x; if(scrollchange == LEFT) - target_x = player->get_bbox().get_middle().x - SCREEN_WIDTH/3*2; + target_x = player->get_bbox().get_middle().x - RIGHTEND; else if(scrollchange == RIGHT) - target_x = player->get_bbox().get_middle().x - SCREEN_WIDTH/3; + target_x = player->get_bbox().get_middle().x - LEFTEND; else target_x = translation.x; diff --git a/src/object/camera.hpp b/src/object/camera.hpp index 260a612ca..0f4d043d5 100644 --- a/src/object/camera.hpp +++ b/src/object/camera.hpp @@ -16,7 +16,6 @@ // 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. - #ifndef SUPERTUX_CAMERA_H #define SUPERTUX_CAMERA_H @@ -38,6 +37,7 @@ class Lisp; class Sector; class Path; class PathWalker; +class CameraConfig; class Camera : public GameObject, public Serializable, public ScriptInterface { @@ -59,9 +59,7 @@ public: virtual void update(float elapsed_time); - virtual void draw(DrawingContext& ) - { - } + virtual void draw(DrawingContext& ); virtual void expose(HSQUIRRELVM vm, SQInteger table_idx); virtual void unexpose(HSQUIRRELVM vm, SQInteger table_idx); @@ -81,6 +79,8 @@ public: */ void scroll_to(const Vector& goal, float scrolltime); + void reload_config(); + enum CameraMode { NORMAL, AUTOSCROLL, SCROLLTO, MANUAL @@ -124,6 +124,8 @@ private: Vector scroll_goal; float scroll_to_pos; float scrollspeed; + + CameraConfig *config; }; #endif /*SUPERTUX_CAMERA_H*/ diff --git a/src/scripting/camera.cpp b/src/scripting/camera.cpp index c0b338e72..ea9098991 100644 --- a/src/scripting/camera.cpp +++ b/src/scripting/camera.cpp @@ -37,9 +37,15 @@ namespace Scripting { } void + Camera::reload_config() + { + camera->reload_config(); + } + + void Camera::shake(float speed, float x, float y) { - camera->shake(speed, x, y); + camera->shake(speed, x, y); } void diff --git a/src/scripting/camera.hpp b/src/scripting/camera.hpp index 325ef6f63..558c207b8 100644 --- a/src/scripting/camera.hpp +++ b/src/scripting/camera.hpp @@ -36,6 +36,8 @@ public: ~Camera(); #endif + void reload_config(); + /** Shake the camera */ void shake(float speed, float x, float y); /** Set camera to a specific coordinate */ diff --git a/src/scripting/wrapper.cpp b/src/scripting/wrapper.cpp index e0ab1c23a..c4a9e6148 100644 --- a/src/scripting/wrapper.cpp +++ b/src/scripting/wrapper.cpp @@ -202,6 +202,30 @@ static SQInteger Camera_release_hook(SQUserPointer ptr, SQInteger ) return 0; } +static SQInteger Camera_reload_config_wrapper(HSQUIRRELVM vm) +{ + SQUserPointer data; + if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) { + sq_throwerror(vm, _SC("'reload_config' called without instance")); + return SQ_ERROR; + } + Scripting::Camera* _this = reinterpret_cast (data); + + try { + _this->reload_config(); + + return 0; + + } catch(std::exception& e) { + sq_throwerror(vm, e.what()); + return SQ_ERROR; + } catch(...) { + sq_throwerror(vm, _SC("Unexpected exception while executing function 'reload_config'")); + return SQ_ERROR; + } + +} + static SQInteger Camera_shake_wrapper(HSQUIRRELVM vm) { SQUserPointer data; @@ -3960,6 +3984,12 @@ void register_supertux_wrapper(HSQUIRRELVM v) msg << "Couldn't create new class 'Camera'"; throw SquirrelError(v, msg.str()); } + sq_pushstring(v, "reload_config", -1); + sq_newclosure(v, &Camera_reload_config_wrapper, 0); + if(SQ_FAILED(sq_createslot(v, -3))) { + throw SquirrelError(v, "Couldn't register function 'reload_config'"); + } + sq_pushstring(v, "shake", -1); sq_newclosure(v, &Camera_shake_wrapper, 0); if(SQ_FAILED(sq_createslot(v, -3))) {