X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fobject%2Fcamera.cpp;h=b9d0097bb8e63a2b43af03d9c13d0e091dfd5d77;hb=ab9eab4c870195c2b60ce76b77044c35b31e8806;hp=367030aa51b32913d48802a85b1ed5ec0acde1dc;hpb=62ff7f7776875e9389d10ae2e7b6348e9e5cb9c7;p=supertux.git diff --git a/src/object/camera.cpp b/src/object/camera.cpp index 367030aa5..b9d0097bb 100644 --- a/src/object/camera.cpp +++ b/src/object/camera.cpp @@ -1,7 +1,7 @@ // $Id$ // -// SuperTux - A Jump'n Run -// Copyright (C) 2004 Matthias Braun // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License @@ -23,29 +23,48 @@ #include #include -#include "lisp/lisp.h" -#include "lisp/writer.h" -#include "lisp/list_iterator.h" -#include "camera.h" -#include "player.h" -#include "tilemap.h" -#include "gameloop.h" -#include "app/globals.h" -#include "sector.h" - -using namespace SuperTux; - -Camera::Camera(Sector* newsector) - : sector(newsector), do_backscrolling(true), scrollchange(NONE), - auto_idx(0), auto_t(0) +#include "lisp/lisp.hpp" +#include "lisp/writer.hpp" +#include "lisp/list_iterator.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" + +Camera::Camera(Sector* newsector, std::string name) + : mode(NORMAL), sector(newsector), do_backscrolling(true), + scrollchange(NONE) { - mode = NORMAL; + this->name = name; } Camera::~Camera() { } +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); +} + +void +Camera::unexpose(HSQUIRRELVM vm, SQInteger table_idx) +{ + if(name.empty()) return; + Scripting::unexpose_object(vm, table_idx, name); +} + const Vector& Camera::get_translation() const { @@ -56,7 +75,7 @@ void Camera::parse(const lisp::Lisp& reader) { std::string modename; - + reader.get("mode", modename); if(modename == "normal") { mode = NORMAL; @@ -64,32 +83,15 @@ Camera::parse(const lisp::Lisp& reader) do_backscrolling = true; reader.get("backscrolling", do_backscrolling); } else if(modename == "autoscroll") { - printf("autoscroll.\n"); mode = AUTOSCROLL; - - const lisp::Lisp* path_lisp = reader.get_lisp("path"); - if(!path_lisp) + + const lisp::Lisp* pathLisp = reader.get_lisp("path"); + if(pathLisp == NULL) throw std::runtime_error("No path specified in autoscroll camera."); - lisp::ListIterator iter(path_lisp); - float speed = .5; - while(iter.next()) { - if(iter.item() != "point") { - std::cerr << "Warning: unknown token '" << iter.item() - << "' in camera path.\n"; - continue; - } - const lisp::Lisp* point_lisp = iter.lisp(); - - ScrollPoint point; - if(!point_lisp->get("x", point.position.x) || - !point_lisp->get("y", point.position.y)) { - throw std::runtime_error("x and y missing in point of camerapath"); - } - point_lisp->get("speed", speed); - point.speed = speed; - scrollpoints.push_back(point); - } + autoscroll_path.reset(new Path()); + autoscroll_path->read(*pathLisp); + autoscroll_walker.reset(new PathWalker(autoscroll_path.get())); } else if(modename == "manual") { mode = MANUAL; } else { @@ -103,73 +105,104 @@ void Camera::write(lisp::Writer& writer) { writer.start_list("camera"); - + if(mode == NORMAL) { writer.write_string("mode", "normal"); writer.write_bool("backscrolling", do_backscrolling); } else if(mode == AUTOSCROLL) { writer.write_string("mode", "autoscroll"); - writer.start_list("path"); - for(std::vector::iterator i = scrollpoints.begin(); - i != scrollpoints.end(); ++i) { - writer.start_list("point"); - writer.write_float("x", i->position.x); - writer.write_float("y", i->position.y); - writer.write_float("speed", i->speed); - writer.end_list("point"); - } - - writer.end_list("path"); + 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->w/3 * 2; - translation.y = tuxpos.y - screen->h/2; - keep_in_bounds(); + translation.x = tuxpos.x - SCREEN_WIDTH/3 * 2; + translation.y = tuxpos.y - SCREEN_HEIGHT/2; + shakespeed = 0; + shaketimer.stop(); + keep_in_bounds(translation); +} + +void +Camera::shake(float time, float x, float y) +{ + shaketimer.start(time); + shakedepth_x = x; + shakedepth_y = y; + shakespeed = M_PI/2 / time; +} + +void +Camera::scroll_to(const Vector& goal, float scrolltime) +{ + scroll_from = translation; + scroll_goal = goal; + keep_in_bounds(scroll_goal); + + scroll_to_pos = 0; + scrollspeed = 1.0 / scrolltime; + mode = SCROLLTO; } static const float EPSILON = .00001; static const float max_speed_y = 140; void -Camera::action(float elapsed_time) +Camera::update(float elapsed_time) { - if(mode == NORMAL) - scroll_normal(elapsed_time); - else if(mode == AUTOSCROLL) - scroll_autoscroll(elapsed_time); + switch(mode) { + case NORMAL: + update_scroll_normal(elapsed_time); + break; + case AUTOSCROLL: + update_scroll_autoscroll(elapsed_time); + break; + case SCROLLTO: + update_scroll_to(elapsed_time); + break; + default: + break; + } } void -Camera::keep_in_bounds() +Camera::keep_in_bounds(Vector& translation) { - float width = sector->solids->get_width() * 32; - float height = sector->solids->get_height() * 32; + 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->h) - translation.y = height - screen->h; - if(translation.y < 0) - translation.y = 0; - if(translation.x > width - screen->w) - translation.x = width - screen->w; + if(translation.y > height - SCREEN_HEIGHT) + translation.y = height - SCREEN_HEIGHT; + if(translation.y < 0) + translation.y = 0; + if(translation.x > width - SCREEN_WIDTH) + translation.x = width - SCREEN_WIDTH; if(translation.x < 0) - translation.x = 0; + translation.x = 0; +} + +void +Camera::shake() +{ + if(shaketimer.started()) { + translation.x -= sin(shaketimer.get_timegone() * shakespeed) * shakedepth_x; + translation.y -= sin(shaketimer.get_timegone() * shakespeed) * shakedepth_y; + } } void -Camera::scroll_normal(float elapsed_time) +Camera::update_scroll_normal(float elapsed_time) { assert(sector != 0); Player* player = sector->player; - + // check that we don't have division by zero later if(elapsed_time < EPSILON) return; @@ -177,7 +210,7 @@ Camera::scroll_normal(float elapsed_time) /****** Vertical Scrolling part ******/ bool do_y_scrolling = true; - if(player->dying || sector->solids->get_height() == 19) + if(player->is_dying() || sector->get_height() == 19*32) do_y_scrolling = false; if(do_y_scrolling) { @@ -192,12 +225,12 @@ Camera::scroll_normal(float elapsed_time) target_y = player->get_bbox().p2.y; // delta_y is the distance we'd have to travel to directly reach target_y - float delta_y = translation.y - (target_y - screen->h/2); + float delta_y = translation.y - (target_y - SCREEN_HEIGHT*2/3); // 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 + if(player->fall_mode != Player::FALLING && player->fall_mode != Player::TRAMPOLINE_JUMP) { if(speed_y > max_speed_y) speed_y = max_speed_y; @@ -207,12 +240,16 @@ Camera::scroll_normal(float elapsed_time) // 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); } /****** Horizontal scrolling part *******/ // 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) @@ -220,19 +257,19 @@ Camera::scroll_normal(float elapsed_time) || (player->dir == ::RIGHT && scrollchange == LEFT)) scrollchange = NONE; // when in left 1/3rd of screen scroll left - if(player->get_bbox().get_middle().x < translation.x + screen->w/3 - 16 + if(player->get_bbox().get_middle().x < translation.x + SCREEN_WIDTH/3 - 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->w/3*2+16) + else if(player->get_bbox().get_middle().x > translation.x + SCREEN_WIDTH/3*2+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->w/3*2; + target_x = player->get_bbox().get_middle().x - SCREEN_WIDTH/3*2; else if(scrollchange == RIGHT) - target_x = player->get_bbox().get_middle().x - screen->w/3; + target_x = player->get_bbox().get_middle().x - SCREEN_WIDTH/3; else target_x = translation.x; @@ -247,45 +284,48 @@ Camera::scroll_normal(float elapsed_time) speed_x = maxv; else if(speed_x < -maxv) speed_x = -maxv; - + + // If player is peeking scroll in that direction. Fast. + if( player->peeking_direction() == ::LEFT ){ + speed_x = maxv; + } + if( player->peeking_direction() == ::RIGHT ){ + speed_x = -maxv; + } + // apply scrolling translation.x -= speed_x * elapsed_time; - keep_in_bounds(); + // make sure to always keep the player inside the middle 4/6 of the screen + translation.x = std::min(player->get_bbox().p1.x - SCREEN_WIDTH*1/6, translation.x); + translation.x = std::max(player->get_bbox().p2.x - SCREEN_WIDTH*5/6, translation.x); + + keep_in_bounds(translation); + shake(); } void -Camera::scroll_autoscroll(float elapsed_time) +Camera::update_scroll_autoscroll(float elapsed_time) { Player* player = sector->player; - - if(player->dying) + if(player->is_dying()) return; - if(auto_t - elapsed_time >= 0) { - translation += current_dir * elapsed_time; - auto_t -= elapsed_time; - } else { - // do the rest of the old movement - translation += current_dir * auto_t; - elapsed_time -= auto_t; - auto_t = 0; - - // construct path for next point - if(auto_idx+1 >= scrollpoints.size()) { - keep_in_bounds(); - return; - } - Vector distance = scrollpoints[auto_idx+1].position - - scrollpoints[auto_idx].position; - current_dir = distance.unit() * scrollpoints[auto_idx].speed; - auto_t = distance.norm() / scrollpoints[auto_idx].speed; - - // do movement for the remaining time - translation += current_dir * elapsed_time; - auto_t -= elapsed_time; - auto_idx++; + translation = autoscroll_walker->advance(elapsed_time); + + keep_in_bounds(translation); + shake(); +} + +void +Camera::update_scroll_to(float elapsed_time) +{ + scroll_to_pos += elapsed_time * scrollspeed; + if(scroll_to_pos >= 1.0) { + mode = MANUAL; + translation = scroll_goal; + return; } - keep_in_bounds(); + translation = scroll_from + (scroll_goal - scroll_from) * scroll_to_pos; }