src/object/camera.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux -  A Jump'n Run
   4 //  Copyright (C) 2004 Matthias Braun <matze@braunis.de
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 #include <config.h>
  21
  22 #include <stdexcept>
  23 #include <sstream>
  24 #include <cmath>
  25
  26 #include "lisp/lisp.h"
  27 #include "lisp/writer.h"
  28 #include "lisp/list_iterator.h"
  29 #include "camera.h"
  30 #include "player.h"
  31 #include "tilemap.h"
  32 #include "gameloop.h"
  33 #include "app/globals.h"
  34 #include "sector.h"
  35 #include "object_factory.h"
  36
  37 using namespace SuperTux;
  38
  39 Camera::Camera(Sector* newsector)
  40   : sector(newsector), do_backscrolling(true), scrollchange(NONE),
  41     auto_idx(0), auto_t(0)
  42 {
  43   mode = NORMAL;
  44 }
  45
  46 Camera::~Camera()
  47 {
  48 }
  49
  50 const Vector&
  51 Camera::get_translation() const
  52 {
  53   return translation;
  54 }
  55
  56 void
  57 Camera::parse(const lisp::Lisp& reader)
  58 {
  59   std::string modename;
  60
  61   reader.get("mode", modename);
  62   if(modename == "normal") {
  63     mode = NORMAL;
  64
  65     do_backscrolling = true;
  66     reader.get("backscrolling", do_backscrolling);
  67   } else if(modename == "autoscroll") {
  68     printf("autoscroll.\n");
  69     mode = AUTOSCROLL;
  70
  71     const lisp::Lisp* path_lisp = reader.get_lisp("path");
  72     if(!path_lisp)
  73       throw std::runtime_error("No path specified in autoscroll camera.");
  74
  75     lisp::ListIterator iter(path_lisp);
  76     float speed = .5;
  77     while(iter.next()) {
  78       if(iter.item() != "point") {
  79         std::cerr << "Warning: unknown token '" << iter.item()
  80           << "' in camera path.\n";
  81         continue;
  82       }
  83       const lisp::Lisp* point_lisp = iter.lisp();
  84
  85       ScrollPoint point;
  86       if(!point_lisp->get("x", point.position.x) ||
  87          !point_lisp->get("y", point.position.y)) {
  88         throw std::runtime_error("x and y missing in point of camerapath");
  89       }
  90       point_lisp->get("speed", speed);
  91       point.speed = speed;
  92       scrollpoints.push_back(point);
  93     }
  94   } else if(modename == "manual") {
  95     mode = MANUAL;
  96   } else {
  97     std::stringstream str;
  98     str << "invalid camera mode '" << modename << "'found in worldfile.";
  99     throw std::runtime_error(str.str());
 100   }
 101 }
 102
 103 void
 104 Camera::write(lisp::Writer& writer)
 105 {
 106   writer.start_list("camera");
 107
 108   if(mode == NORMAL) {
 109     writer.write_string("mode", "normal");
 110     writer.write_bool("backscrolling", do_backscrolling);
 111   } else if(mode == AUTOSCROLL) {
 112     writer.write_string("mode", "autoscroll");
 113     writer.start_list("path");
 114     for(std::vector<ScrollPoint>::iterator i = scrollpoints.begin();
 115         i != scrollpoints.end(); ++i) {
 116       writer.start_list("point");
 117       writer.write_float("x", i->position.x);
 118       writer.write_float("y", i->position.y);
 119       writer.write_float("speed", i->speed);
 120       writer.end_list("point");
 121     }
 122
 123     writer.end_list("path");
 124   } else if(mode == MANUAL) {
 125     writer.write_string("mode", "manual");
 126   }
 127
 128   writer.end_list("camera");
 129 }
 130
 131 void
 132 Camera::reset(const Vector& tuxpos)
 133 {
 134   translation.x = tuxpos.x - screen->w/3 * 2;
 135   translation.y = tuxpos.y - screen->h/2;
 136   keep_in_bounds();
 137 }
 138
 139 static const float EPSILON = .00001;
 140 static const float max_speed_y = 140;
 141
 142 void
 143 Camera::action(float elapsed_time)
 144 {
 145   if(mode == NORMAL)
 146     scroll_normal(elapsed_time);
 147   else if(mode == AUTOSCROLL)
 148     scroll_autoscroll(elapsed_time);
 149 }
 150
 151 void
 152 Camera::keep_in_bounds()
 153 {
 154   float width = sector->solids->get_width() * 32;
 155   float height = sector->solids->get_height() * 32;
 156
 157   // don't scroll before the start or after the level's end
 158   if(translation.y > height - screen->h)
 159     translation.y = height - screen->h;
 160   if(translation.y < 0)
 161     translation.y = 0;
 162   if(translation.x > width - screen->w)
 163     translation.x = width - screen->w;
 164   if(translation.x < 0)
 165     translation.x = 0;
 166 }
 167
 168 void
 169 Camera::scroll_normal(float elapsed_time)
 170 {
 171   assert(sector != 0);
 172   Player* player = sector->player;
 173
 174   // check that we don't have division by zero later
 175   if(elapsed_time < EPSILON)
 176     return;
 177
 178   /****** Vertical Scrolling part ******/
 179   bool do_y_scrolling = true;
 180
 181   if(player->is_dying() || sector->solids->get_height() == 19)
 182     do_y_scrolling = false;
 183
 184   if(do_y_scrolling) {
 185     // target_y is the high we target our scrolling at. This is not always the
 186     // high of the player, but if he is jumping upwards we should use the
 187     // position where he last touched the ground. (this probably needs
 188     // exceptions for trampolines and similar things in the future)
 189     float target_y;
 190     if(player->fall_mode == Player::JUMPING)
 191       target_y = player->last_ground_y + player->get_bbox().get_height();
 192     else
 193       target_y = player->get_bbox().p2.y;
 194
 195     // delta_y is the distance we'd have to travel to directly reach target_y
 196     float delta_y = translation.y - (target_y - screen->h/2);
 197     // speed is the speed the camera would need to reach target_y in this frame
 198     float speed_y = delta_y / elapsed_time;
 199
 200     // limit the camera speed when jumping upwards
 201     if(player->fall_mode != Player::FALLING
 202         && player->fall_mode != Player::TRAMPOLINE_JUMP) {
 203       if(speed_y > max_speed_y)
 204         speed_y = max_speed_y;
 205       else if(speed_y < -max_speed_y)
 206         speed_y = -max_speed_y;
 207     }
 208
 209     // finally scroll with calculated speed
 210     translation.y -= speed_y * elapsed_time;
 211   }
 212
 213   /****** Horizontal scrolling part *******/
 214
 215   // our camera is either in leftscrolling, rightscrolling or nonscrollingmode.
 216
 217   // when suddenly changing directions while scrolling into the other direction.
 218   // abort scrolling, since tux might be going left/right at a relatively small
 219   // part of the map (like when jumping upwards)
 220   if((player->dir == ::LEFT && scrollchange == RIGHT)
 221       || (player->dir == ::RIGHT && scrollchange == LEFT))
 222     scrollchange = NONE;
 223   // when in left 1/3rd of screen scroll left
 224   if(player->get_bbox().get_middle().x < translation.x + screen->w/3 - 16
 225       && do_backscrolling)
 226     scrollchange = LEFT;
 227   // scroll right when in right 1/3rd of screen
 228   else if(player->get_bbox().get_middle().x > translation.x + screen->w/3*2+16)
 229     scrollchange = RIGHT;
 230
 231   // calculate our scroll target depending on scroll mode
 232   float target_x;
 233   if(scrollchange == LEFT)
 234     target_x = player->get_bbox().get_middle().x - screen->w/3*2;
 235   else if(scrollchange == RIGHT)
 236     target_x = player->get_bbox().get_middle().x - screen->w/3;
 237   else
 238     target_x = translation.x;
 239
 240   // that's the distance we would have to travel to reach target_x
 241   float delta_x = translation.x - target_x;
 242   // the speed we'd need to travel to reach target_x in this frame
 243   float speed_x = delta_x / elapsed_time;
 244
 245   // limit our speed
 246   float maxv = 130 + (fabsf(player->physic.get_velocity_x() * 1.3));
 247   if(speed_x > maxv)
 248     speed_x = maxv;
 249   else if(speed_x < -maxv)
 250     speed_x = -maxv;
 251
 252   // apply scrolling
 253   translation.x -= speed_x * elapsed_time;
 254
 255   keep_in_bounds();
 256 }
 257
 258 void
 259 Camera::scroll_autoscroll(float elapsed_time)
 260 {
 261   Player* player = sector->player;
 262
 263   if(player->is_dying())
 264     return;
 265
 266   if(auto_t - elapsed_time >= 0) {
 267     translation += current_dir * elapsed_time;
 268     auto_t -= elapsed_time;
 269   } else {
 270     // do the rest of the old movement
 271     translation += current_dir * auto_t;
 272     elapsed_time -= auto_t;
 273     auto_t = 0;
 274
 275     // construct path for next point
 276     if(auto_idx+1 >= scrollpoints.size()) {
 277       keep_in_bounds();
 278       return;
 279     }
 280     Vector distance = scrollpoints[auto_idx+1].position
 281                       - scrollpoints[auto_idx].position;
 282     current_dir = distance.unit() * scrollpoints[auto_idx].speed;
 283     auto_t = distance.norm() / scrollpoints[auto_idx].speed;
 284
 285     // do movement for the remaining time
 286     translation += current_dir * elapsed_time;
 287     auto_t -= elapsed_time;
 288     auto_idx++;
 289   }
 290
 291   keep_in_bounds();
 292 }
 293