X-Git-Url: https://git.octo.it/?a=blobdiff_plain;ds=sidebyside;f=src%2Fplayer.cpp;h=9d06c188e021ed61e70ec5a3628e28100525cc3f;hb=00fb759c2385ff08caf38e916c2d0ba8cafc8a41;hp=3d5e05774366808d459df9af19eaab6f0e5ea816;hpb=b7c38ba2b2044c286dacb341c420b364343eb8d6;p=supertux.git

diff --git a/src/player.cpp b/src/player.cpp
index 3d5e05774..2ecaaadc5 100644
--- a/src/player.cpp
+++ b/src/player.cpp
@@ -1,1024 +1,1024 @@
+//  $Id$
 //
-// C Implementation: player/tux
+//  SuperTux -  A Jump'n Run
+//  Copyright (C) 2003 Tobias Glaesser <tobi.web@gmx.de>
 //
-// Description:
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
 //
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
 //
-// Author: Tobias Glaesser <tobi.web@gmx.de> & Bill Kendrick, (C) 2004
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-
-#include "gameloop.h"
-#include "globals.h"
+//  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 <typeinfo>
+#include <cmath>
+#include <iostream>
+#include <cassert>
+
+#include "app/globals.h"
+#include "app/gettext.h"
 #include "player.h"
 #include "defines.h"
 #include "scene.h"
-#include "screen.h"
-
-texture_type tux_life,
-tux_right[3],  tux_left[3],
-bigtux_right[3],  bigtux_left[3],
-bigtux_right_jump,  bigtux_left_jump,
-ducktux_right,  ducktux_left,
-skidtux_right,  skidtux_left,
-firetux_right[3],  firetux_left[3],
-bigfiretux_right[3],  bigfiretux_left[3],
-bigfiretux_right_jump,  bigfiretux_left_jump,
-duckfiretux_right,  duckfiretux_left,
-skidfiretux_right,  skidfiretux_left,
-cape_right[2],  cape_left[2],
-bigcape_right[2],  bigcape_left[2];
+#include "tile.h"
+#include "special/sprite.h"
+#include "sector.h"
+#include "tilemap.h"
+#include "camera.h"
+#include "gameobjs.h"
+#include "resources.h"
+#include "video/screen.h"
+#include "statistics.h"
+#include "gameloop.h"
+#include "trigger/trigger_base.h"
+
+// behavior definitions:
+#define TILES_FOR_BUTTJUMP 3
+// animation times (in ms):
+#define SHOOTING_TIME .150
+
+// time before idle animation starts
+#define IDLE_TIME 2.500
+
+// growing animation
+Surface* growingtux_left[GROWING_FRAMES];
+Surface* growingtux_right[GROWING_FRAMES];
+
+Surface* tux_life = 0;
+
+Sprite* smalltux_gameover = 0;
+Sprite* smalltux_star = 0;
+Sprite* bigtux_star = 0;
+
+TuxBodyParts* small_tux = 0;
+TuxBodyParts* big_tux = 0;
+TuxBodyParts* fire_tux = 0;
+TuxBodyParts* ice_tux = 0;
+
+PlayerKeymap keymap;
+
+PlayerKeymap::PlayerKeymap()
+{
+  keymap.up    = SDLK_UP;
+  keymap.down  = SDLK_DOWN;
+  keymap.left  = SDLK_LEFT;
+  keymap.right = SDLK_RIGHT;
+
+  keymap.power = SDLK_LCTRL;
+  keymap.jump  = SDLK_LALT;
+}
 
 void player_input_init(player_input_type* pplayer_input)
 {
+  pplayer_input->up = UP;
+  pplayer_input->old_up = UP;
   pplayer_input->down = UP;
   pplayer_input->fire = UP;
   pplayer_input->left = UP;
   pplayer_input->old_fire = UP;
   pplayer_input->right = UP;
-  pplayer_input->up = UP;
+  pplayer_input->jump = UP;
+  pplayer_input->old_jump = UP;
+  pplayer_input->activate = UP;
 }
 
-void player_init(player_type* pplayer)
+void
+TuxBodyParts::set_action(std::string action)
 {
-  pplayer->base.width = 32;
-  pplayer->base.height = 32;
-
-  pplayer->size = SMALL;
-  pplayer->got_coffee = NO;
-
-  pplayer->base.x = 0;
-  pplayer->base.y = 240;
-  pplayer->base.xm = 0;
-  pplayer->base.ym = 0;
-  pplayer->old_base = pplayer->base;
-  pplayer->dir = RIGHT;
-  pplayer->duck = NO;
-
-  pplayer->dying = NO;
-  pplayer->jumping = NO;
-
-  pplayer->frame_main = 0;
-  pplayer->frame = 0;
-  pplayer->lives = 3;
-  pplayer->score = 0;
-  pplayer->distros = 0;
-
-  player_input_init(&pplayer->input);
-
-  pplayer->keymap.jump = SDLK_UP;
-  pplayer->keymap.duck = SDLK_DOWN;
-  pplayer->keymap.left = SDLK_LEFT;
-  pplayer->keymap.right = SDLK_RIGHT;
-  pplayer->keymap.fire = SDLK_LCTRL;
-
-  timer_init(&pplayer->invincible_timer,YES);
-  timer_init(&pplayer->skidding_timer,YES);
-  timer_init(&pplayer->safe_timer,YES);
-  timer_init(&pplayer->frame_timer,YES);
-  physic_init(&pplayer->hphysic);
-  physic_init(&pplayer->vphysic);
+  if(head != NULL)
+    head->set_action(action);
+  if(body != NULL)
+    body->set_action(action);
+  if(arms != NULL)
+    arms->set_action(action);
+  if(feet != NULL)
+    feet->set_action(action);
 }
 
-int player_key_event(player_type* pplayer, SDLKey key, int state)
+void
+TuxBodyParts::one_time_animation()
 {
-  if(key == pplayer->keymap.right)
-    {
-      pplayer->input.right = state;
-      return YES;
-    }
-  else if( key == pplayer->keymap.left)
-    {
-      pplayer->input.left = state;
-      return YES;
-    }
-  else if(key == pplayer->keymap.jump)
-    {
-      pplayer->input.up = state;
-      return YES;
-    }
-  else if(key == pplayer->keymap.duck)
-    {
-      pplayer->input.down = state;
-      return YES;
-    }
-  else if(key == pplayer->keymap.fire)
-    {
-      pplayer->input.fire = state;
-      return YES;
-    }
-  else
-    return NO;
+  if(head != NULL)
+    head->start_animation(1);
+  if(body != NULL)
+    body->start_animation(1);
+  if(arms != NULL)
+    arms->start_animation(1);
+  if(feet != NULL)
+    feet->start_animation(1);
 }
 
-void player_level_begin(player_type* pplayer)
+void
+TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer,
+                  Uint32 drawing_effect)
 {
-  pplayer->base.x = 0;
-  pplayer->base.y = 240;
-  pplayer->base.xm = 0;
-  pplayer->base.ym = 0;
-  pplayer->old_base = pplayer->base;
-
-  player_input_init(&pplayer->input);
-
-  timer_init(&pplayer->invincible_timer,YES);
-  timer_init(&pplayer->skidding_timer,YES);
-  timer_init(&pplayer->safe_timer,YES);
-  timer_init(&pplayer->frame_timer,YES);
-  physic_init(&pplayer->hphysic);
-  physic_init(&pplayer->vphysic);
+  if(head != NULL)
+    head->draw(context, pos, layer-1, drawing_effect);
+  if(body != NULL)
+    body->draw(context, pos, layer-3, drawing_effect);
+  if(arms != NULL)
+    arms->draw(context, pos, layer,   drawing_effect);
+  if(feet != NULL)
+    feet->draw(context, pos, layer-2, drawing_effect);
 }
 
-void player_action(player_type* pplayer)
+Player::Player()
 {
-  int i, jumped_in_solid;
-  jumped_in_solid = NO;
+  init();
+}
 
-  /* --- HANDLE TUX! --- */
+Player::~Player()
+{
+}
 
-  player_input(pplayer);
+void
+Player::init()
+{
+  holding_something = false;
 
-  /* Move tux: */
+  bbox.set_size(32, 32);
 
-  pplayer->previous_base = pplayer->base;
+  size = SMALL;
+  got_power = NONE_POWER;
 
-  pplayer->base.x += pplayer->base.xm * frame_ratio;
-  pplayer->base.y += pplayer->base.ym * frame_ratio;
+  dir = RIGHT;
+  old_dir = dir;
+  duck = false;
+  dead = false;
 
-  collision_swept_object_map(&pplayer->old_base,&pplayer->base);
+  dying   = DYING_NOT;
+  last_ground_y = 0;
+  fall_mode = ON_GROUND;
+  jumping = false;
+  flapping = false;
+  can_jump = true;
+  can_flap = false;
+  falling_from_flap = false;
+  enable_hover = false;
+  butt_jump = false;
+  
+  flapping_velocity = 0;
 
-  player_keep_in_bounds(pplayer);
+  // temporary to help player's choosing a flapping
+  flapping_mode = MAREK_FLAP;
 
-  /* Land: */
+  // Ricardo's flapping
+  flaps_nb = 0;
 
-  if (!pplayer->dying)
-    {
+  on_ground_flag = false;
 
+  player_input_init(&input);
 
-      if( !player_on_ground(pplayer))
-        {
-          if(player_under_solid(pplayer))
-            {
-              physic_set_state(&pplayer->vphysic,PH_VT);
-              physic_set_start_vy(&pplayer->vphysic,0);
-              jumped_in_solid = YES;
-            }
-          else
-            {
-              if(!physic_is_set(&pplayer->vphysic))
-                {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
-                  physic_set_start_vy(&pplayer->vphysic,0);
-                }
-            }
-          pplayer->base.ym = physic_get_velocity(&pplayer->vphysic);
-
-        }
-      else
-        {
+  physic.reset();
+}
 
-          /* Land: */
+int
+Player::key_event(SDLKey key, int state)
+{
+  idle_timer.start(IDLE_TIME, true);
 
-          if (pplayer->base.ym > 0)
-            {
-              pplayer->base.y = (int)(((int)pplayer->base.y / 32) * 32);
-              pplayer->base.ym = 0;
-            }
+  if(key == keymap.right)
+    {
+      input.right = state;
+      return true;
+    }
+  else if(key == keymap.left)
+    {
+      input.left = state;
+      return true;
+    }
+  else if(key == keymap.up)
+    {
+      if(state == UP)
+        input.old_up = UP;
+      input.up = state;
+      /* Up key also opens activates stuff */
+      input.activate = state;
+      return true;
+    }
+  else if(key == keymap.down)
+    {
+      input.down = state;
+      return true;
+    }
+  else if(key == keymap.power)
+    {
+      if (state == UP)
+        input.old_fire = UP;
+      input.fire = state;
 
-          physic_init(&pplayer->vphysic);
+      return true;
+    }
+  else if(key == keymap.jump)
+    {
+      if (state == UP)
+        input.old_jump = UP;
+      input.jump = state;
+      return true;
+    }
+  else
+    return false;
+}
 
-          /* Reset score multiplier (for multi-hits): */
+void
+Player::level_begin()
+{
+  move(Vector(100, 170));
+  duck = false;
 
-          score_multiplier = 1;
-        }
+  dying = DYING_NOT;
 
-      if(jumped_in_solid == YES)
-        {
+  player_input_init(&input);
 
-          if (isbrick(pplayer->base.x, pplayer->base.y) ||
-              isfullbox(pplayer->base.x, pplayer->base.y))
-            {
-              trygrabdistro(pplayer->base.x, pplayer->base.y - 32,BOUNCE);
-              trybumpbadguy(pplayer->base.x, pplayer->base.y - 64);
+  on_ground_flag = false;
 
-              if(pplayer->size == BIG)
-                trybreakbrick(pplayer->base.x, pplayer->base.y);
+  physic.reset();
+}
 
-              bumpbrick(pplayer->base.x, pplayer->base.y);
-              tryemptybox(pplayer->base.x, pplayer->base.y, RIGHT);
-            }
+PlayerStatus&
+Player::get_status()
+{
+  return player_status;
+}
 
-          if (isbrick(pplayer->base.x+ 31, pplayer->base.y) ||
-              isfullbox(pplayer->base.x+ 31, pplayer->base.y))
-            {
-              trygrabdistro(pplayer->base.x+ 31, pplayer->base.y - 32,BOUNCE);
-              trybumpbadguy(pplayer->base.x+ 31, pplayer->base.y - 64);
+void
+Player::action(float elapsed_time)
+{
+  if(dying && dying_timer.check()) {
+    dead = true;
+    return;
+  }
 
-              if(pplayer->size == BIG)
-                trybreakbrick(pplayer->base.x+ 31, pplayer->base.y);
+  if (input.fire == UP)
+    holding_something = false;
 
-              bumpbrick(pplayer->base.x+ 31, pplayer->base.y);
-              tryemptybox(pplayer->base.x+ 31, pplayer->base.y, LEFT);
-            }
+  if(dying == DYING_NOT)
+    handle_input();
 
+  movement = physic.get_movement(elapsed_time);
 
-          if(pplayer->size == SMALL)
-            {
-              /* Get a distro from a brick? */
-
-              if (shape(pplayer->base.x, pplayer->base.y) == 'x' ||
-                  shape(pplayer->base.x, pplayer->base.y) == 'y')
-                {
-                  add_bouncy_distro((((int)pplayer->base.x)
-                                     / 32) * 32,
-                                    ((int)pplayer->base.y / 32) * 32);
-                  if (counting_distros == NO)
-                    {
-                      counting_distros = YES;
-                      distro_counter = 100;
-                    }
-
-                  if (distro_counter <= 0)
-                    level_change(&current_level,pplayer->base.x,pplayer->base.y - 1, 'a');
-
-                  play_sound(sounds[SND_DISTRO], SOUND_CENTER_SPEAKER);
-                  score = score + SCORE_DISTRO;
-                  distros++;
-                }
-              else if (shape(pplayer->base.x+ 31, pplayer->base.y) == 'x' ||
-                       shape(pplayer->base.x+ 31, pplayer->base.y) == 'y')
-                {
-                  add_bouncy_distro((((int)pplayer->base.x + 31)
-                                     / 32) * 32,
-                                    ((int)pplayer->base.y / 32) * 32);
-                  if (counting_distros == NO)
-                    {
-                      counting_distros = YES;
-                      distro_counter = 100;
-                    }
-
-                  if (distro_counter <= 0)
-                    level_change(&current_level,pplayer->base.x+ 31, pplayer->base.y, 'a');
-
-                  play_sound(sounds[SND_DISTRO], SOUND_CENTER_SPEAKER);
-                  score = score + SCORE_DISTRO;
-                  distros++;
-                }
-            }
+#if 0
+      // special exception for cases where we're stuck under tiles after
+      // being ducked. In this case we drift out
+      if(!duck && on_ground() && old_base.x == base.x && old_base.y == base.y
+         && collision_object_map(base))
+        {
+          base.x += elapsed_time * WALK_SPEED * (dir ? 1: -1);
+          previous_base = old_base = base;
         }
 
-      player_grabdistros(pplayer);
-      if(jumped_in_solid == YES)
-        {
-          ++pplayer->base.y;
-          ++pplayer->old_base.y;
-          if(player_on_ground(pplayer))
+      /* Reset score multiplier (for multi-hits): */
+      if (!invincible_timer.started())
             {
-              /* Make sure jumping is off. */
-              pplayer->jumping = NO;
+            if(player_status.score_multiplier > player_status.max_score_multiplier)
+              {
+              player_status.max_score_multiplier = player_status.score_multiplier;
+
+              // show a message
+              char str[124];
+              sprintf(str, _("New max combo: %d"), player_status.max_score_multiplier-1);
+              Sector::current()->add_floating_text(base, str);
+              }
+            player_status.score_multiplier = 1;
             }
         }
 
     }
+#endif
 
-  timer_check(&pplayer->safe_timer);
-
-
-  /* ---- DONE HANDLING TUX! --- */
-
-  /* Handle invincibility timer: */
+  on_ground_flag = false;
+}
 
+bool
+Player::on_ground()
+{
+  return on_ground_flag;
+}
 
-  if (get_current_music() == HERRING_MUSIC && !timer_check(&pplayer->invincible_timer))
+void
+Player::handle_horizontal_input()
+{
+  float vx = physic.get_velocity_x();
+  float vy = physic.get_velocity_y();
+  float ax = physic.get_acceleration_x();
+  float ay = physic.get_acceleration_y();
+
+  float dirsign = 0;
+  if(input.left == DOWN && input.right == UP && (!duck || physic.get_velocity_y() != 0)) {
+      old_dir = dir;
+      dir = LEFT;
+      dirsign = -1;
+  } else if(input.left == UP && input.right == DOWN && (!duck || physic.get_velocity_y() != 0)) {
+      old_dir = dir;
+      dir = RIGHT;
+      dirsign = 1;
+  }
+
+  if (input.fire == UP) {
+      ax = dirsign * WALK_ACCELERATION_X;
+      // limit speed
+      if(vx >= MAX_WALK_XM && dirsign > 0) {
+        vx = MAX_WALK_XM;
+        ax = 0;
+      } else if(vx <= -MAX_WALK_XM && dirsign < 0) {
+        vx = -MAX_WALK_XM;
+        ax = 0;
+      }
+  } else {
+      ax = dirsign * RUN_ACCELERATION_X;
+      // limit speed
+      if(vx >= MAX_RUN_XM && dirsign > 0) {
+        vx = MAX_RUN_XM;
+        ax = 0;
+      } else if(vx <= -MAX_RUN_XM && dirsign < 0) {
+        vx = -MAX_RUN_XM;
+        ax = 0;
+      }
+  }
+
+  // we can reach WALK_SPEED without any acceleration
+  if(dirsign != 0 && fabs(vx) < WALK_SPEED) {
+    vx = dirsign * WALK_SPEED;
+  }
+
+  // changing directions?
+  if(on_ground() && ((vx < 0 && dirsign >0) || (vx>0 && dirsign<0)))
     {
-      /*
-         no, we are no more invincible
-         or we were not in invincible mode
-         but are we in hurry ?
-       */
-
-
-      if (timer_get_left(&time_left) < TIME_WARNING)
+      // let's skid!
+      if(fabs(vx)>SKID_XM && !skidding_timer.started())
         {
-          /* yes, we are in hurry
-             stop the herring_song, prepare to play the correct
-             fast level_song !
-           */
-          set_current_music(HURRYUP_MUSIC);
+          skidding_timer.start(SKID_TIME);
+          SoundManager::get()->play_sound(IDToSound(SND_SKID));
+          // dust some partcles
+          Sector::current()->add_object(
+              new Particles(
+                Vector(bbox.p1.x + (dir == RIGHT ? bbox.get_width() : 0),
+                bbox.p2.y),
+              dir == RIGHT ? 270+20 : 90-40, dir == RIGHT ? 270+40 : 90-20,
+              Vector(280,-260), Vector(0,0.030), 3, Color(100,100,100), 3, .8,
+              LAYER_OBJECTS+1));
+
+          ax *= 2.5;
         }
       else
         {
-          set_current_music(LEVEL_MUSIC);
+          ax *= 2;
         }
-
-      /* start playing it */
-      play_current_music();
     }
 
-  /* Handle skidding: */
-
-  timer_check(&pplayer->skidding_timer);
-
-  /* End of level? */
+  // we get slower when not pressing any keys
+  if(dirsign == 0) {
+      if(fabs(vx) < WALK_SPEED) {
+          vx = 0;
+          ax = 0;
+      } else if(vx < 0) {
+          ax = WALK_ACCELERATION_X * 1.5;
+      } else {
+          ax = WALK_ACCELERATION_X * -1.5;
+      }
+  }
+
+#if 0
+  // if we're on ice slow down acceleration or deceleration
+  if (isice(base.x, base.y + base.height))
+  {
+    /* the acceleration/deceleration rate on ice is inversely proportional to
+     * the current velocity.
+     */
+
+    // increasing 1 will increase acceleration/deceleration rate
+    // decreasing 1 will decrease acceleration/deceleration rate
+    //  must stay above zero, though
+    if (ax != 0) ax *= 1 / fabs(vx);
+  }
+#endif
+
+  physic.set_velocity(vx, vy);
+  physic.set_acceleration(ax, ay);
+}
 
-  if (pplayer->base.x >= endpos && endpos != 0)
-    {
-      next_level = 1;
+void
+Player::handle_vertical_input()
+{
+  // set fall mode...
+  if(on_ground()) {
+    fall_mode = ON_GROUND;
+    last_ground_y = get_pos().y;
+  } else {
+    if(get_pos().y > last_ground_y)
+      fall_mode = FALLING;
+    else if(fall_mode == ON_GROUND)
+      fall_mode = JUMPING;
+  }
+
+  if(on_ground()) { /* Make sure jumping is off. */
+    jumping = false;
+    flapping = false;
+    falling_from_flap = false;
+    if (flapping_timer.started()) {
+      flapping_timer.start(0);
     }
 
-}
+    physic.set_acceleration_y(0); //for flapping
+  }
 
-int player_on_ground(player_type *pplayer)
-{
-  if( issolid(pplayer->base.x + pplayer->base.width / 2, pplayer->base.y + pplayer->base.height) ||
-      issolid(pplayer->base.x + 1, pplayer->base.y + pplayer->base.height) ||
-      issolid(pplayer->base.x + pplayer->base.width - 1, pplayer->base.y + pplayer->base.height)  )
+  // Press jump key
+  if(input.jump == DOWN && can_jump && on_ground())
     {
-      return YES;
+      if(duck) { // only jump a little bit when in duck mode {
+        physic.set_velocity_y(300);
+      } else {
+        // jump higher if we are running
+        if (fabs(physic.get_velocity_x()) > MAX_WALK_XM)
+          physic.set_velocity_y(580);
+        else
+          physic.set_velocity_y(520);
+      }
+
+      //bbox.move(Vector(0, -1));
+      jumping = true;
+      flapping = false;
+      can_jump = false;
+      can_flap = false;
+      flaps_nb = 0; // Ricardo's flapping
+      if (size == SMALL)
+        SoundManager::get()->play_sound(IDToSound(SND_JUMP));
+      else
+        SoundManager::get()->play_sound(IDToSound(SND_BIGJUMP));
     }
-  else
+  // Let go of jump key
+  else if(input.jump == UP)
     {
-      return NO;
+      if (!flapping && !duck && !falling_from_flap && !on_ground())
+         {
+            can_flap = true;
+         }
+      if (jumping && physic.get_velocity_y() > 0)
+         {
+            jumping = false;
+            physic.set_velocity_y(0);
+         }
     }
-}
 
-int player_under_solid(player_type *pplayer)
-{
-  if( issolid(pplayer->base.x + pplayer->base.width / 2, pplayer->base.y) ||
-      issolid(pplayer->base.x + 1, pplayer->base.y) ||
-      issolid(pplayer->base.x + pplayer->base.width - 1, pplayer->base.y)  )
+ // temporary to help player's choosing a flapping
+ if(flapping_mode == RICARDO_FLAP)
+   {
+   // Flapping, Ricardo's version
+   // similar to SM3 Fox
+   if(input.jump == DOWN && input.old_jump == UP && can_flap &&
+     flaps_nb < 3)
+     {
+       physic.set_velocity_y(350);
+       physic.set_velocity_x(physic.get_velocity_x() * 35);
+       flaps_nb++;
+     }
+   }
+  else if(flapping_mode == MAREK_FLAP)
+   {
+   // Flapping, Marek's version
+   if (input.jump == DOWN && can_flap)
+     {
+         if (!flapping_timer.started())
+            {
+               flapping_timer.start(TUX_FLAPPING_TIME);
+               flapping_velocity = physic.get_velocity_x();
+            }
+         if (flapping_timer.check()) 
+            {
+               can_flap = false;
+               falling_from_flap = true;
+            }
+         jumping = true;
+         flapping = true;
+         if (!flapping_timer.check()) {
+           float cv = flapping_velocity * sqrt(
+               TUX_FLAPPING_TIME - flapping_timer.get_timegone() 
+               / TUX_FLAPPING_TIME);
+
+           //Handle change of direction while flapping
+           if (((dir == LEFT) && (cv > 0)) || (dir == RIGHT) && (cv < 0)) {
+             cv *= (-1);
+           }
+           physic.set_velocity_x(cv);
+           physic.set_velocity_y(
+               flapping_timer.get_timegone()/.850);
+         }
+     }
+   }
+  else if(flapping_mode == RYAN_FLAP)
+   {
+   // Flapping, Ryan's version
+   if (input.jump == DOWN && can_flap)
+     {
+         if (!flapping_timer.started())
+            {
+               flapping_timer.start(TUX_FLAPPING_TIME);
+            }
+         if (flapping_timer.check()) 
+            {
+               can_flap = false;
+               falling_from_flap = true;
+            }
+         jumping = true;
+         flapping = true;
+         if (flapping && flapping_timer.get_timegone() <= TUX_FLAPPING_TIME
+                && physic.get_velocity_y() < 0)
+            {
+               float gravity = Sector::current()->gravity;
+               (void)gravity;
+               float xr = (fabsf(physic.get_velocity_x()) / MAX_RUN_XM);
+
+               // XXX: magic numbers. should be a percent of gravity
+               //      gravity is (by default) -0.1f
+               physic.set_acceleration_y(12 + 1*xr);
+
+#if 0
+               // To slow down x-vel when flapping (not working)
+               if (fabsf(physic.get_velocity_x()) > MAX_WALK_XM)
+               {
+                   if (physic.get_velocity_x() < 0)
+                       physic.set_acceleration_x(1.0f);
+                   else if (physic.get_velocity_x() > 0)
+                       physic.set_acceleration_x(-1.0f);
+               }
+#endif
+            }
+     }
+    else
+     {
+        physic.set_acceleration_y(0);
+     }
+   }
+
+   // Hover
+   //(disabled by default, use cheat code "hover" to toggle on/off)
+   //TODO: needs some tweaking, especially when used together with double jump and jumping off badguys
+   if (enable_hover && input.jump == DOWN && !jumping && !butt_jump && physic.get_velocity_y() <= 0)
+      {
+         physic.set_velocity_y(-100);
+      }
+
+#if 0
+   /* In case the player has pressed Down while in a certain range of air,
+      enable butt jump action */
+  if (input.down == DOWN && !butt_jump && !duck)
+    if(tiles_on_air(TILES_FOR_BUTTJUMP) && jumping)
+      butt_jump = true;
+#endif
+
+   /* When Down is not held anymore, disable butt jump */
+  if(butt_jump && input.down == UP)
+    butt_jump = false;
+
+  // Do butt jump
+  if (butt_jump && on_ground() && size == BIG)
+  {
+    // Add a smoke cloud
+    if (duck) 
+      Sector::current()->add_smoke_cloud(Vector(get_pos().x - 32, get_pos().y));
+    else 
+      Sector::current()->add_smoke_cloud(
+          Vector(get_pos().x - 32, get_pos().y + 32));
+    
+    butt_jump = false;
+
+#if 0
+    // Break bricks beneath Tux
+    if(Sector::current()->trybreakbrick(
+          Vector(base.x + 1, base.y + base.height), false)
+        || Sector::current()->trybreakbrick(
+           Vector(base.x + base.width - 1, base.y + base.height), false))
     {
-      return YES;
+      physic.set_velocity_y(2);
+      butt_jump = true;
     }
-  else
+#endif
+
+#if 0
+    // Kill nearby badguys
+    std::vector<GameObject*> gameobjects = Sector::current()->gameobjects;
+    for (std::vector<GameObject*>::iterator i = gameobjects.begin();
+         i != gameobjects.end();
+         i++)
+    {
+      BadGuy* badguy = dynamic_cast<BadGuy*> (*i);
+      if(badguy)
+      {
+        // don't kill when badguys are already dying or in a certain mode
+        if(badguy->dying == DYING_NOT && badguy->mode != BadGuy::BOMB_TICKING &&
+           badguy->mode != BadGuy::BOMB_EXPLODE)
+          {
+            if (fabsf(base.x - badguy->base.x) < 96 &&
+                fabsf(base.y - badguy->base.y) < 64)
+              badguy->kill_me(25);
+          }
+      }
+    }
+#endif
+  }
+
+  /** jumping is only allowed if we're about to touch ground soon and if the
+   * button has been up in between the last jump
+   */
+  // FIXME
+#if 0
+  if ( (issolid(get_pos().x + bbox.get_width() / 2,
+          get_pos().y + bbox.get_height() + 64) ||
+        issolid(get_pos().x + 1, get_pos().y + bbox.get_height() + 64) ||
+        issolid(get_pos().x + bbox.get_width() - 1,
+          get_pos().y + bbox.get_height() + 64))
+       && jumping  == false
+       && can_jump == false
+       && input.jump == DOWN
+       && input.old_jump == UP)
     {
-      return NO;
+      can_jump = true;
     }
+#endif
+
+  input.old_jump = input.jump;
 }
 
-void player_handle_horizontal_input(player_type *pplayer, int dir)
+void
+Player::handle_input()
 {
+  /* Handle horizontal movement: */
+  handle_horizontal_input();
 
-  if ((dir ? (pplayer->base.xm < -SKID_XM) : (pplayer->base.xm > SKID_XM)) && !timer_started(&pplayer->skidding_timer) &&
-      pplayer->dir == !dir && player_on_ground(pplayer))
-    {
-      timer_start(&pplayer->skidding_timer, SKID_TIME);
-
-      play_sound(sounds[SND_SKID], SOUND_CENTER_SPEAKER);
-
-    }
-  pplayer->dir = dir;
+  /* Jump/jumping? */
+  if (on_ground() && input.jump == UP)
+    can_jump = true;
+  handle_vertical_input();
 
+  /* Shoot! */
+  if (input.fire == DOWN && input.old_fire == UP && got_power != NONE_POWER) {
+    if(Sector::current()->add_bullet(
+          get_pos() + Vector(0, bbox.get_height()/2),
+          physic.get_velocity_x(), dir))
+      shooting_timer.start(SHOOTING_TIME);
+    input.old_fire = DOWN;
+  }
 
-  if ((dir ? (pplayer->base.xm < 0) : (pplayer->base.xm > 0)) && !isice(pplayer->base.x, pplayer->base.y + pplayer->base.height) &&
-      !timer_started(&pplayer->skidding_timer))
+  /* Duck! */
+  if (input.down == DOWN && size == BIG && !duck 
+      && physic.get_velocity_y() == 0 && on_ground())
     {
-      pplayer->base.xm = 0;
+      duck = true;
+      bbox.move(Vector(0, 32));
+      bbox.set_height(32);
     }
-
-  if (!pplayer->duck)
+  else if(input.down == UP && size == BIG && duck)
     {
-      if (pplayer->dir == dir)
-        {
-          /* Facing the direction we're jumping?  Go full-speed: */
-
-          if (pplayer->input.fire == UP)
-            {
-              pplayer->base.xm = pplayer->base.xm + ( dir ? WALK_SPEED : -WALK_SPEED) * frame_ratio;
-
-              if(dir)
-                {
-                  if (pplayer->base.xm > MAX_WALK_XM)
-                    pplayer->base.xm = MAX_WALK_XM;
-                }
-              else
-                {
-                  if (pplayer->base.xm < -MAX_WALK_XM)
-                    pplayer->base.xm = -MAX_WALK_XM;
-                }
-            }
-          else if ( pplayer->input.fire == DOWN)
-            {
-              pplayer->base.xm = pplayer->base.xm + ( dir ? RUN_SPEED : -RUN_SPEED) * frame_ratio;
-
-              if(dir)
-                {
-                  if (pplayer->base.xm > MAX_RUN_XM)
-                    pplayer->base.xm = MAX_RUN_XM;
-                }
-              else
-                {
-                  if (pplayer->base.xm < -MAX_RUN_XM)
-                    pplayer->base.xm = -MAX_RUN_XM;
-                }
-            }
-          else
-            {
-              /* Not facing the direction we're jumping?
-              Go half-speed: */
-
-              pplayer->base.xm = pplayer->base.xm + ( dir ? (WALK_SPEED / 2) : -(WALK_SPEED / 2)) * frame_ratio;
-
-              if(dir)
-                {
-                  if (pplayer->base.xm > MAX_WALK_XM / 2)
-                    pplayer->base.xm = MAX_WALK_XM / 2;
-                }
-              else
-                {
-                  if (pplayer->base.xm < -MAX_WALK_XM / 2)
-                    pplayer->base.xm = -MAX_WALK_XM / 2;
-                }
-            }
-        }
-
+      // try if we can really unduck
+      bbox.move(Vector(0, -32));
+      bbox.set_height(64);
+      duck = false;
+      // FIXME
+#if 0
+      // when unducking in air we need some space to do so
+      if(on_ground() || !collision_object_map(bbox)) {
+        duck = false;
+      } else {
+        // undo the ducking changes
+        bbox.move(Vector(0, 32));
+        bbox.set_height(32);
+      }
+#endif
     }
 }
 
-void player_handle_vertical_input(player_type *pplayer)
+void
+Player::grow(bool animate)
 {
-  if(pplayer->input.up == DOWN)
-    {
-      if (player_on_ground(pplayer))
-        {
-          if(!physic_is_set(&pplayer->vphysic))
-            {
-              physic_set_state(&pplayer->vphysic,PH_VT);
-              physic_set_start_vy(&pplayer->vphysic,5.5);
-              --pplayer->base.y;
-              pplayer->jumping = YES;
-              if (pplayer->size == SMALL)
-                play_sound(sounds[SND_JUMP], SOUND_CENTER_SPEAKER);
-              else
-                play_sound(sounds[SND_BIGJUMP], SOUND_CENTER_SPEAKER);
-            }
-        }
-    }
-  else if(pplayer->input.up == UP && pplayer->jumping == YES)
-    {
-      if (player_on_ground(pplayer))
-        {
-          physic_init(&pplayer->vphysic);
-          pplayer->jumping == NO;
-        }
-      else
-        {
-          pplayer->jumping = NO;
-          if(physic_is_set(&pplayer->vphysic))
-            {
-              if(physic_get_velocity(&pplayer->vphysic) < 0.)
-                {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
-                  physic_set_start_vy(&pplayer->vphysic,0);
-                }
-            }
-          else
-            {
-              if(!physic_is_set(&pplayer->vphysic))
-                {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
-                }
-            }
-        }
-    }
+  if(size == BIG)
+    return;
+  
+  size = BIG;
+  bbox.set_height(64);
+  bbox.move(Vector(0, -32));
+
+  if(animate)
+    growing_timer.start(GROWING_TIME);
 }
 
-void player_input(player_type *pplayer)
+void
+Player::grabdistros()
 {
-  /* Handle key and joystick state: */
+}
 
-  if(pplayer->duck == NO)
-    {
-      if (pplayer->input.right == DOWN && pplayer->input.left == UP)
-        {
-          player_handle_horizontal_input(pplayer,RIGHT);
-        }
-      else if (pplayer->input.left == DOWN && pplayer->input.right == UP)
-        {
-          player_handle_horizontal_input(pplayer,LEFT);
-        }
-      else
-        {
-          if(pplayer->base.xm > 0)
-            {
-              pplayer->base.xm = (int)(pplayer->base.xm - frame_ratio);
-              if(pplayer->base.xm < 0)
-                pplayer->base.xm = 0;
-            }
-          else if(pplayer->base.xm < 0)
-            {
-              pplayer->base.xm = (int)(pplayer->base.xm + frame_ratio);
-              if(pplayer->base.xm > 0)
-                pplayer->base.xm = 0;
-            }
-        }
-    }
+void
+Player::draw(DrawingContext& context)
+{
+  TuxBodyParts* tux_body;
+          
+  if (size == SMALL)
+    tux_body = small_tux;
+  else if (got_power == FIRE_POWER)
+    tux_body = fire_tux;
+  else if (got_power == ICE_POWER)
+    tux_body = ice_tux;
+  else
+    tux_body = big_tux;
 
-  /* Jump/jumping? */
+  int layer = LAYER_OBJECTS - 1;
 
-  if ( pplayer->input.up == DOWN || (pplayer->input.up == UP && pplayer->jumping == YES))
+  /* Set Tux sprite action */
+  if (duck && size == BIG)
     {
-      player_handle_vertical_input(pplayer);
+    if(dir == LEFT)
+      tux_body->set_action("duck-left");
+    else // dir == RIGHT
+      tux_body->set_action("duck-right");
     }
-
-  /* Shoot! */
-
-  if (pplayer->input.fire == DOWN && pplayer->input.old_fire == UP && pplayer->got_coffee)
+  else if (skidding_timer.started() && !skidding_timer.check())
     {
-      add_bullet(pplayer->base.x, pplayer->base.y, pplayer->base.xm, pplayer->dir);
+    if(dir == LEFT)
+      tux_body->set_action("skid-left");
+    else // dir == RIGHT
+      tux_body->set_action("skid-right");
     }
-
-
-  /* Duck! */
-
-  if (pplayer->input.down == DOWN)
+  else if (kick_timer.started() && !kick_timer.check())
     {
-      if (pplayer->size == BIG && pplayer->duck != YES)
-        {
-          pplayer->duck = YES;
-          pplayer->base.height = 32;
-          pplayer->base.y += 32;
-        }
+    if(dir == LEFT)
+      tux_body->set_action("kick-left");
+    else // dir == RIGHT
+      tux_body->set_action("kick-right");
+    }
+  else if (butt_jump && size == BIG)
+    {
+    if(dir == LEFT)
+      tux_body->set_action("buttjump-left");
+    else // dir == RIGHT
+      tux_body->set_action("buttjump-right");
+    }
+  else if (physic.get_velocity_y() != 0)
+    {
+    if(dir == LEFT)
+      tux_body->set_action("jump-left");
+    else // dir == RIGHT
+      tux_body->set_action("jump-right");
     }
   else
     {
-      if (pplayer->size == BIG && pplayer->duck == YES)
-        {
-          /* Make sure we're not standing back up into a solid! */
-          pplayer->base.height = 64;
-          pplayer->base.y -= 32;
-
-          if (!collision_object_map(&pplayer->base) /*issolid(pplayer->base.x + 16, pplayer->base.y - 16)*/)
-            {
-              pplayer->duck = NO;
-              pplayer->base.height = 64;
-              pplayer->old_base.y -= 32;
-              pplayer->old_base.height = 64;
-            }
-          else
-            {
-              pplayer->base.height = 32;
-              pplayer->base.y += 32;
-            }
-        }
-      else
-        {
-          pplayer->duck = NO;
-        }
+    if (fabsf(physic.get_velocity_x()) < 1.0f) // standing
+      {
+      if(dir == LEFT)
+        tux_body->set_action("stand-left");
+      else // dir == RIGHT
+        tux_body->set_action("stand-right");
+      }
+    else // moving
+      {
+      if(dir == LEFT)
+        tux_body->set_action("walk-left");
+      else // dir == RIGHT
+        tux_body->set_action("walk-right");
+      }
     }
 
-  /* (Tux): */
-
-  if(!timer_check(&pplayer->frame_timer))
+  if(idle_timer.check())
     {
-      timer_start(&pplayer->frame_timer,25);
-      if (pplayer->input.right == UP && pplayer->input.left == UP)
-        {
-          pplayer->frame_main = 1;
-          pplayer->frame = 1;
-        }
-      else
-        {
-          if ((pplayer->input.fire == DOWN && (frame % 2) == 0) ||
-              (frame % 4) == 0)
-            pplayer->frame_main = (pplayer->frame_main + 1) % 4;
+    if(size == BIG)
+      {
+      if(dir == LEFT)
+        tux_body->head->set_action("idle-left");
+      else // dir == RIGHT
+        tux_body->head->set_action("idle-right");
 
-          pplayer->frame = pplayer->frame_main;
+      tux_body->head->start_animation(1);
+      }
 
-          if (pplayer->frame == 3)
-            pplayer->frame = 1;
-        }
     }
 
-}
-
-void player_grabdistros(player_type *pplayer)
-{
-  /* Grab distros: */
-  if (!pplayer->dying)
+  // Tux is holding something
+  if ((holding_something && physic.get_velocity_y() == 0) ||
+      (shooting_timer.get_timeleft() > 0 && !shooting_timer.check()))
     {
-      trygrabdistro(pplayer->base.x, pplayer->base.y, NO_BOUNCE);
-      trygrabdistro(pplayer->base.x+ 31, pplayer->base.y, NO_BOUNCE);
-
-      trygrabdistro(pplayer->base.x, pplayer->base.y + pplayer->base.height, NO_BOUNCE);
-      trygrabdistro(pplayer->base.x+ 31, pplayer->base.y + pplayer->base.height, NO_BOUNCE);
-
-      if(pplayer->size == BIG)
-        {
-          trygrabdistro(pplayer->base.x, pplayer->base.y + pplayer->base.height / 2, NO_BOUNCE);
-          trygrabdistro(pplayer->base.x+ 31, pplayer->base.y + pplayer->base.height / 2, NO_BOUNCE);
-        }
-
+    if (duck)
+      {
+      if(dir == LEFT)
+        tux_body->arms->set_action("duck+grab-left");
+      else // dir == RIGHT
+        tux_body->arms->set_action("duck+grab-right");
+      }
+    else
+      {
+      if(dir == LEFT)
+        tux_body->arms->set_action("grab-left");
+      else // dir == RIGHT
+        tux_body->arms->set_action("grab-right");
+      }
     }
 
-
-  /* Enough distros for a One-up? */
-
-  if (distros >= DISTROS_LIFEUP)
-    {
-      distros = distros - DISTROS_LIFEUP;
-      if(pplayer->lives < MAX_LIVES)
-        pplayer->lives++;
-      /*We want to hear the sound even, if MAX_LIVES is reached*/
-      play_sound(sounds[SND_LIFEUP], SOUND_CENTER_SPEAKER);
+  /* Draw Tux */
+  if (dying == DYING_SQUISHED) {
+    smalltux_gameover->draw(context, get_pos(), LAYER_FOREGROUNDTILES+1);
+  } else if(growing_timer.get_timeleft() > 0) {
+    if(size == SMALL)
+      {
+      if (dir == RIGHT)
+        context.draw_surface(growingtux_right[GROWING_FRAMES-1 - 
+                 int((growing_timer.get_timegone() *
+                 GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
+      else
+        context.draw_surface(growingtux_left[GROWING_FRAMES-1 - 
+                int((growing_timer.get_timegone() *
+                GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
+      }
+    else
+      {
+      if (dir == RIGHT)
+        context.draw_surface(growingtux_right[
+            int((growing_timer.get_timegone() *
+                GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
+      else
+        context.draw_surface(growingtux_left[
+            int((growing_timer.get_timegone() *
+                             GROWING_FRAMES) / GROWING_TIME)],
+            get_pos(), layer);
+      }
     }
+  else if (safe_timer.started() && size_t(global_time*40)%2)
+    ;  // don't draw Tux
+  else
+    tux_body->draw(context, get_pos(), layer);
+
+  // Draw blinking star overlay
+  if (invincible_timer.started() &&
+     (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING
+      || size_t(global_time*20)%2)
+     && !dying)
+  {
+    if (size == SMALL || duck)
+      smalltux_star->draw(context, get_pos(), LAYER_OBJECTS + 2);
+    else
+      bigtux_star->draw(context, get_pos(), LAYER_OBJECTS + 2);
+  }
+ 
+  if (debug_mode)
+    context.draw_filled_rect(get_pos(),
+        Vector(bbox.get_width(), bbox.get_height()),
+        Color(75,75,75, 150), LAYER_OBJECTS+1);
 }
 
-void player_draw(player_type* pplayer)
+HitResponse
+Player::collision(GameObject& other, const CollisionHit& hit)
 {
-  if (!timer_started(&pplayer->safe_timer) || (frame % 2) == 0)
-    {
-      if (pplayer->size == SMALL)
-        {
-          if (timer_started(&pplayer->invincible_timer))
-            {
-              /* Draw cape: */
-
-              if (pplayer->dir == RIGHT)
-                {
-                  texture_draw(&cape_right[frame % 2],
-                               pplayer->base.x- scroll_x, pplayer->base.y,
-                               NO_UPDATE);
-                }
-              else
-                {
-                  texture_draw(&cape_left[frame % 2],
-                               pplayer->base.x- scroll_x, pplayer->base.y,
-                               NO_UPDATE);
-                }
-            }
+  if(dying) {
+    return FORCE_MOVE;
+  }
+
+  if(other.get_flags() & FLAG_SOLID) {
+    if(hit.normal.y < 0) { // landed on floor?
+      if (physic.get_velocity_y() < 0)
+        physic.set_velocity_y(0);
+      on_ground_flag = true;
+    } else if(hit.normal.y > 0) { // bumped against the roof
+      physic.set_velocity_y(0);
+    }
+    
+    if(hit.normal.x != 0) { // hit on the side?
+      if(hit.normal.y > 0.6) // limits the slopes we can move up...
+        physic.set_velocity_x(0);
+    }
 
+    return CONTINUE;
+  }
 
-          if (!pplayer->got_coffee)
-            {
-              if (pplayer->dir == RIGHT)
-                {
-                  texture_draw(&tux_right[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y, NO_UPDATE);
-                }
-              else
-                {
-                  texture_draw(&tux_left[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y, NO_UPDATE);
-                }
-            }
-          else
-            {
-              /* Tux got coffee! */
-
-              if (pplayer->dir == RIGHT)
-                {
-                  texture_draw(&firetux_right[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y, NO_UPDATE);
-                }
-              else
-                {
-                  texture_draw(&firetux_left[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y, NO_UPDATE);
-                }
-            }
-        }
-      else
-        {
-          if (timer_started(&pplayer->invincible_timer))
-            {
-              /* Draw cape: */
-
-              if (pplayer->dir == RIGHT)
-                {
-                  texture_draw(&bigcape_right[frame % 2],
-                               pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                               NO_UPDATE);
-                }
-              else
-                {
-                  texture_draw(&bigcape_left[frame % 2],
-                               pplayer->base.x-scroll_x - 8, pplayer->base.y,
-                               NO_UPDATE);
-                }
-            }
+  TriggerBase* trigger = dynamic_cast<TriggerBase*> (&other);
+  if(trigger) {
+    if(input.up == DOWN && input.old_up == UP)
+      trigger->event(*this, TriggerBase::EVENT_ACTIVATE);
+  }
 
-          if (!pplayer->got_coffee)
-            {
-              if (!pplayer->duck)
-                {
-                  if (!timer_started(&pplayer->skidding_timer))
-                    {
-                      if (!pplayer->jumping || pplayer->base.ym > 0)
-                        {
-                          if (pplayer->dir == RIGHT)
-                            {
-                              texture_draw(&bigtux_right[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                          else
-                            {
-                              texture_draw(&bigtux_left[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                        }
-                      else
-                        {
-                          if (pplayer->dir == RIGHT)
-                            {
-                              texture_draw(&bigtux_right_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                          else
-                            {
-                              texture_draw(&bigtux_left_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                        }
-                    }
-                  else
-                    {
-                      if (pplayer->dir == RIGHT)
-                        {
-                          texture_draw(&skidtux_right,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                       NO_UPDATE);
-                        }
-                      else
-                        {
-                          texture_draw(&skidtux_left,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                       NO_UPDATE);
-                        }
-                    }
-                }
-              else
-                {
-                  if (pplayer->dir == RIGHT)
-                    {
-                      texture_draw(&ducktux_right, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16,
-                                   NO_UPDATE);
-                    }
-                  else
-                    {
-                      texture_draw(&ducktux_left, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16,
-                                   NO_UPDATE);
-                    }
-                }
-            }
-          else
-            {
-              /* Tux has coffee! */
-
-              if (!pplayer->duck)
-                {
-                  if (!timer_started(&pplayer->skidding_timer))
-                    {
-                      if (!pplayer->jumping || pplayer->base.ym > 0)
-                        {
-                          if (pplayer->dir == RIGHT)
-                            {
-                              texture_draw(&bigfiretux_right[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                          else
-                            {
-                              texture_draw(&bigfiretux_left[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                        }
-                      else
-                        {
-                          if (pplayer->dir == RIGHT)
-                            {
-                              texture_draw(&bigfiretux_right_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                          else
-                            {
-                              texture_draw(&bigfiretux_left_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                           NO_UPDATE);
-                            }
-                        }
-                    }
-                  else
-                    {
-                      if (pplayer->dir == RIGHT)
-                        {
-                          texture_draw(&skidfiretux_right,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                       NO_UPDATE);
-                        }
-                      else
-                        {
-                          texture_draw(&skidfiretux_left,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y,
-                                       NO_UPDATE);
-                        }
-                    }
-                }
-              else
-                {
-                  if (pplayer->dir == RIGHT)
-                    {
-                      texture_draw(&duckfiretux_right, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16,
-                                   NO_UPDATE);
-                    }
-                  else
-                    {
-                      texture_draw(&duckfiretux_left, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16,
-                                   NO_UPDATE);
-                    }
-                }
-            }
-        }
-    }
+  return FORCE_MOVE;
 }
 
-void player_collision(player_type* pplayer, void* p_c_object, int c_object)
+void
+Player::make_invincible()
 {
-  bad_guy_type* pbad_c = NULL;
-
-  switch (c_object)
-    {
-    case CO_BADGUY:
-      pbad_c = (bad_guy_type*) p_c_object;
-      /* Hurt the player if he just touched it: */
-
-      if (!pbad_c->dying && !pplayer->dying &&
-          !timer_started(&pplayer->safe_timer) &&
-          pbad_c->mode != HELD)
-        {
-          if (pbad_c->mode == FLAT  && pplayer->input.fire != DOWN)
-            {
-              /* Kick: */
-
-              pbad_c->mode = KICK;
-              play_sound(sounds[SND_KICK], SOUND_CENTER_SPEAKER);
-
-              if (pplayer->base.x < pbad_c->base.x + (pbad_c->base.width/2))
-                {
-                  pbad_c->dir = RIGHT;
-                  pbad_c->base.x = pbad_c->base.x + 16;
-                }
-              else
-                {
-                  pbad_c->dir = LEFT;
-                  pbad_c->base.x = pbad_c->base.x - 32;
-                }
-
-              timer_start(&pbad_c->timer,5000);
-            }
-          else if (pbad_c->mode == FLAT && pplayer->input.fire == DOWN)
-            {
-              pbad_c->mode = HELD;
-              pbad_c->base.y-=8;
-            }
-          else if (pbad_c->mode == KICK)
-            {
-              if (pplayer->base.y < pbad_c->base.y - 16 &&
-                  timer_started(&pbad_c->timer))
-                {
-                  /* Step on (stop being kicked) */
-
-                  pbad_c->mode = FLAT;
-                  play_sound(sounds[SND_STOMP], SOUND_CENTER_SPEAKER);
-                  timer_start(&pbad_c->timer, 10000);
-                }
-              else
-                {
-                  /* Hurt if you get hit by kicked laptop: */
-
-                  if (timer_started(&pbad_c->timer))
-                    {
-                      if (!timer_started(&pplayer->invincible_timer))
-                        {
-                          player_kill(pplayer,SHRINK);
-                        }
-                      else
-                        {
-                          pbad_c->dying = FALLING;
-                          play_sound(sounds[SND_FALL], SOUND_CENTER_SPEAKER);
-                          add_score(pbad_c->base.x - scroll_x,
-                                    pbad_c->base.y,
-                                    25 * score_multiplier);
-                        }
-                    }
-                }
-            }
-          else
-            {
-              if (!timer_started(&pplayer->invincible_timer ))
-                {
-                  player_kill(pplayer,SHRINK);
-                }
-              else
-                {
-                  pbad_c->dying = FALLING;
-                  play_sound(sounds[SND_FALL], SOUND_CENTER_SPEAKER);
-                  add_score(pbad_c->base.x - scroll_x,
-                            pbad_c->base.y,
-                            25 * score_multiplier);
-                }
-            }
-          score_multiplier++;
-        }
-      break;
-    default:
-      break;
-    }
-
+  SoundManager::get()->play_sound(IDToSound(SND_HERRING));
+  invincible_timer.start(TUX_INVINCIBLE_TIME);
+  Sector::current()->play_music(HERRING_MUSIC);               
 }
 
 /* Kill Player! */
-
-void player_kill(player_type* pplayer, int mode)
+void
+Player::kill(HurtMode mode)
 {
-  pplayer->base.ym = -5;
+  if(dying)
+    return;
 
-  play_sound(sounds[SND_HURT], SOUND_CENTER_SPEAKER);
+  if(safe_timer.get_timeleft() > 0 || invincible_timer.get_timeleft() > 0)
+    return;                          
+  
+  SoundManager::get()->play_sound(IDToSound(SND_HURT));
 
-  if (pplayer->dir == RIGHT)
-    pplayer->base.xm = -8;
-  else if (pplayer->dir == LEFT)
-    pplayer->base.xm = 8;
+  physic.set_velocity_x(0);
 
-  if (mode == SHRINK && pplayer->size == BIG)
+  if (mode == SHRINK && size == BIG)
     {
-      if (pplayer->got_coffee)
-        pplayer->got_coffee = NO;
-
-      pplayer->size = SMALL;
-      pplayer->base.height = 32;
-
-      timer_start(&pplayer->safe_timer,TUX_SAFE_TIME);
+      if (got_power != NONE_POWER)
+        {
+          safe_timer.start(TUX_SAFE_TIME);
+          got_power = NONE_POWER;
+        }
+      else
+        {
+          growing_timer.start(GROWING_TIME);
+          safe_timer.start(TUX_SAFE_TIME + GROWING_TIME);
+          size = SMALL;
+          bbox.set_height(32);
+          duck = false;
+        }
     }
   else
     {
-      pplayer->dying = 1;
+      physic.enable_gravity(true);
+      physic.set_acceleration(0, 0);
+      physic.set_velocity(0, 700);
+      --player_status.lives;
+      dying = DYING_SQUISHED;
+      dying_timer.start(3.0);
     }
 }
 
-void player_dying(player_type *pplayer)
+/* Remove Tux's power ups */
+void
+Player::remove_powerups()
 {
-  pplayer->base.ym = pplayer->base.ym + gravity;
-
-  /* He died :^( */
-
-  --pplayer->lives;
-  player_remove_powerups(pplayer);
-  pplayer->dying = NO;
-
-  player_level_begin(pplayer);
-
+  got_power = NONE_POWER;
+  size = SMALL;
+  bbox.set_height(32);
 }
 
-/* Remove Tux's power ups */
-void player_remove_powerups(player_type* pplayer)
+void
+Player::move(const Vector& vector)
 {
-  pplayer->got_coffee = NO;
-  pplayer->size = SMALL;
-  pplayer->base.height = 32;
+  bbox.set_pos(vector);
 }
 
-void player_keep_in_bounds(player_type* pplayer)
+void
+Player::check_bounds(Camera* camera)
 {
   /* Keep tux in bounds: */
-  if (pplayer->base.x< 0)
-    pplayer->base.x= 0;
-  else if(pplayer->base.x< scroll_x)
-    pplayer->base.x= scroll_x;
-  else if (pplayer->base.x< 160 + scroll_x && scroll_x > 0 && debug_mode == YES)
-    {
-      scroll_x = pplayer->base.x- 160;
-      /*pplayer->base.x+= 160;*/
-
-      if(scroll_x < 0)
-        scroll_x = 0;
-
+  if (get_pos().x < 0)
+    { // Lock Tux to the size of the level, so that he doesn't fall of
+      // on the left side
+      bbox.set_pos(Vector(0, get_pos().y));
     }
-  else if (pplayer->base.x> screen->w / 2 + scroll_x && scroll_x < ((current_level.width * 32) - screen->w))
-    {
-      /* Scroll the screen in past center: */
 
-      scroll_x = pplayer->base.x- screen->w / 2;
-      /*pplayer->base.x= 320 + scroll_x;*/
-
-      if (scroll_x > ((current_level.width * 32) - screen->w))
-        scroll_x = ((current_level.width * 32) - screen->w);
-    }
-  else if (pplayer->base.x> 608 + scroll_x)
+  /* Keep in-bounds, vertically: */
+  if (get_pos().y > Sector::current()->solids->get_height() * 32)
     {
-      /* ... unless there's no more to scroll! */
-
-      /*pplayer->base.x= 608 + scroll_x;*/
+      kill(KILL);
+      return;
     }
 
-  /* Keep in-bounds, vertically: */
-
-  if (pplayer->base.y > screen->h)
-    {
-      player_kill(&tux,KILL);
+  bool adjust = false;
+  // can happen if back scrolling is disabled
+  if(get_pos().x < camera->get_translation().x) {
+    bbox.set_pos(Vector(camera->get_translation().x, get_pos().y));
+    adjust = true;
+  }
+  if(get_pos().x >= camera->get_translation().x + screen->w - bbox.get_width())
+  {
+    bbox.set_pos(Vector(
+          camera->get_translation().x + screen->w - bbox.get_width(),
+          get_pos().y));
+    adjust = true;
+  }
+
+  if(adjust) {
+    // FIXME
+#if 0
+    // squished now?
+    if(collision_object_map(bbox)) {
+      kill(KILL);
+      return;
     }
+#endif
+  }
+}
+
+void
+Player::bounce(BadGuy& badguy)
+{
+  //Make sure we stopped flapping
+  flapping = false;
+  falling_from_flap = false;
+  
+  if (input.jump)
+    physic.set_velocity_y(520);
+  else
+    physic.set_velocity_y(200);
 }
+