experimental code to influence camera, adjusted some parameters, tried to improve...

SVN-Revision: 4913

diff --git a/data/camera.cfg b/data/camera.cfg
new file mode 100644 (file)
index 0000000..a8d9a70
--- /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 e4fd50a..25a2d92 100644 (file)
--- 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<typename T>
-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 260a612..0f4d043 100644 (file)
--- 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 c0b338e..ea90989 100644 (file)
--- 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 325ef6f..558c207 100644 (file)
--- 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 e0ab1c2..c4a9e61 100644 (file)
--- 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<Scripting::Camera*> (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))) {