// $Id$
//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
+// SuperTux
+// Copyright (C) 2006 Matthias Braun <matze@braunis.de>
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// 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 <config.h>
#include <stdexcept>
#include <sstream>
#include <cmath>
-#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"
+
+namespace {
+ enum CameraStyle { CameraStyleYI, CameraStyleKD, CameraStyleEXP };
+ const CameraStyle cameraStyle = CameraStyleYI;
+}
+
+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
{
Camera::parse(const lisp::Lisp& reader)
{
std::string modename;
-
+
reader.get("mode", modename);
if(modename == "normal") {
mode = NORMAL;
reader.get("backscrolling", do_backscrolling);
} else if(modename == "autoscroll") {
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 {
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<ScrollPoint>::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_kd(const Vector& tuxpos)
+{
+ translation.x = tuxpos.x - (SCREEN_WIDTH * 0.5);
+ translation.y = tuxpos.y - (SCREEN_HEIGHT * 0.5);
+
+ shakespeed = 0;
+ shaketimer.stop();
+ keep_in_bounds(translation);
+}
+
+
+void
Camera::reset(const Vector& tuxpos)
{
- translation.x = tuxpos.x - screen->w/3 * 2;
- translation.y = tuxpos.y - screen->h/2;
- keep_in_bounds();
+ if (cameraStyle == CameraStyleKD) {
+ reset_kd(tuxpos);
+ return;
+ }
+
+ 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;
}
-static const float EPSILON = .00001;
+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 = .00001f;
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 (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;
+ translation.x = 0;
+ if (width < SCREEN_WIDTH)
+ translation.x = width/2.0 - SCREEN_WIDTH/2.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::update_scroll_normal_kd(float elapsed_time)
+{
+ // make sure some time has actually passed
+ if(elapsed_time < EPSILON) return;
+
+ // make sure we have an active player
+ assert(sector != 0);
+ 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;
+ }
+
+ // 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 (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);
+ }
+
+ // 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);
+
+ // make sure camera doesn't point outside level borders
+ keep_in_bounds(translation);
+
+ // handle shaking of camera (if applicable)
+ shake();
+}
+
+template<typename T>
+T clamp(T min, T max, T val)
+{
+ if(val < min)
+ return min;
+ if(val > max)
+ return max;
+
+ return val;
}
void
-Camera::scroll_normal(float elapsed_time)
+Camera::update_scroll_normal_exp(float elapsed_time)
{
+ static const Vector camera_speed = Vector(300, 100);
+
+ Player* player = sector->player;
+ const Vector& player_pos = player->get_bbox().get_middle();
+ static Vector last_player_pos = player_pos;
+ static Vector camera_delta = Vector(0, 0);
+
+ (void) elapsed_time;
+
+ Vector player_delta_x = player_pos - last_player_pos;
+ last_player_pos = player_pos;
+
+ Vector camera_delta_antic = Vector(0, 0) + player_delta_x * 25;
+ Vector myspeed = (camera_delta_antic - camera_delta) / elapsed_time;
+ myspeed.x = clamp(-camera_speed.x, camera_speed.x, myspeed.x);
+ myspeed.y = clamp(-camera_speed.y, camera_speed.y, myspeed.y);
+
+ camera_delta += myspeed * elapsed_time;
+
+ translation.x = camera_delta.x + player_pos.x - 0.5f * SCREEN_WIDTH;
+ translation.y = camera_delta.y + player_pos.y - 0.5f * SCREEN_HEIGHT;
+
+ keep_in_bounds(translation);
+ shake();
+}
+
+void
+Camera::update_scroll_normal(float elapsed_time)
+{
+ if (cameraStyle == CameraStyleEXP) {
+ update_scroll_normal_exp(elapsed_time);
+ return;
+ }
+ if (cameraStyle == CameraStyleKD) {
+ update_scroll_normal_kd(elapsed_time);
+ return;
+ }
+
assert(sector != 0);
Player* player = sector->player;
-
+
// check that we don't have division by zero later
if(elapsed_time < EPSILON)
return;
/****** 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) {
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;
// 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)
- if((player->dir == ::LEFT && scrollchange == RIGHT)
- || (player->dir == ::RIGHT && scrollchange == LEFT))
+
+
+ // Find out direction in which the player walks: We want to try and show a
+ // bit more of what's in front of the player and less of what's behind
+ 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;
+
+
+ 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->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;
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;
}