src/object/player.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2006 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 #include <config.h>
  20
  21 #include <typeinfo>
  22 #include <cmath>
  23 #include <iostream>
  24 #include <cassert>
  25
  26 #include "gettext.hpp"
  27 #include "sprite/sprite_manager.hpp"
  28 #include "audio/sound_manager.hpp"
  29 #include "player.hpp"
  30 #include "tile.hpp"
  31 #include "sprite/sprite.hpp"
  32 #include "sector.hpp"
  33 #include "resources.hpp"
  34 #include "statistics.hpp"
  35 #include "game_session.hpp"
  36 #include "object/tilemap.hpp"
  37 #include "object/camera.hpp"
  38 #include "object/particles.hpp"
  39 #include "object/portable.hpp"
  40 #include "object/bullet.hpp"
  41 #include "trigger/trigger_base.hpp"
  42 #include "control/joystickkeyboardcontroller.hpp"
  43 #include "scripting/squirrel_util.hpp"
  44 #include "main.hpp"
  45 #include "platform.hpp"
  46 #include "badguy/badguy.hpp"
  47 #include "player_status.hpp"
  48 #include "log.hpp"
  49 #include "falling_coin.hpp"
  50 #include "random_generator.hpp"
  51 #include "object/sprite_particle.hpp"
  52 #include "trigger/climbable.hpp"
  53
  54 //#define SWIMMING
  55
  56 static const int TILES_FOR_BUTTJUMP = 3;
  57 static const float SHOOTING_TIME = .150f;
  58 /// time before idle animation starts
  59 static const float IDLE_TIME = 2.5f;
  60
  61 /** acceleration in horizontal direction when walking
  62  * (all acceleratiosn are in  pixel/s^2) */
  63 static const float WALK_ACCELERATION_X = 300;
  64 /** acceleration in horizontal direction when running */
  65 static const float RUN_ACCELERATION_X = 400;
  66 /** acceleration when skidding */
  67 static const float SKID_XM = 200;
  68 /** time of skidding in seconds */
  69 static const float SKID_TIME = .3f;
  70 /** maximum walk velocity (pixel/s) */
  71 static const float MAX_WALK_XM = 230;
  72 /** maximum run velcoity (pixel/s) */
  73 static const float MAX_RUN_XM = 320;
  74 /** maximum horizontal climb velocity */
  75 static const float MAX_CLIMB_XM = 48;
  76 /** maximum vertical climb velocity */
  77 static const float MAX_CLIMB_YM = 128;
  78 /** instant velocity when tux starts to walk */
  79 static const float WALK_SPEED = 100;
  80
  81 /** time of the kick (kicking mriceblock) animation */
  82 static const float KICK_TIME = .3f;
  83 /** time of tux cheering (currently unused) */
  84 static const float CHEER_TIME = 1.0f;
  85
  86 /** if Tux cannot unduck for this long, he will get hurt */
  87 static const float UNDUCK_HURT_TIME = 0.25f;
  88
  89 // growing animation
  90 Surface* growingtux_left[GROWING_FRAMES];
  91 Surface* growingtux_right[GROWING_FRAMES];
  92
  93 Surface* tux_life = 0;
  94
  95 TuxBodyParts* small_tux = 0;
  96 TuxBodyParts* big_tux = 0;
  97 TuxBodyParts* fire_tux = 0;
  98 TuxBodyParts* ice_tux = 0;
  99
 100 namespace{
 101   bool no_water = true;
 102 }
 103 void
 104 TuxBodyParts::set_action(std::string action, int loops)
 105 {
 106   if(head != NULL)
 107     head->set_action(action, loops);
 108   if(body != NULL)
 109     body->set_action(action, loops);
 110   if(arms != NULL)
 111     arms->set_action(action, loops);
 112   if(feet != NULL)
 113     feet->set_action(action, loops);
 114 }
 115
 116 void
 117 TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer, Portable* grabbed_object)
 118 {
 119   if(head != NULL)
 120     head->draw(context, pos, layer-2);
 121   if(body != NULL)
 122     body->draw(context, pos, layer-4);
 123   if(arms != NULL)
 124     arms->draw(context, pos, layer-1 + (grabbed_object?10:0));
 125   if(feet != NULL)
 126     feet->draw(context, pos, layer-3);
 127 }
 128
 129 Player::Player(PlayerStatus* _player_status, const std::string& name)
 130   : scripting_controller(0),
 131     player_status(_player_status),
 132     scripting_controller_old(0),
 133     grabbed_object(NULL), ghost_mode(false), edit_mode(false), climbing(0)
 134 {
 135   this->name = name;
 136   controller = main_controller;
 137   scripting_controller = new CodeController();
 138   smalltux_gameover = sprite_manager->create("images/creatures/tux_small/smalltux-gameover.sprite");
 139   smalltux_star = sprite_manager->create("images/creatures/tux_small/smalltux-star.sprite");
 140   bigtux_star = sprite_manager->create("images/creatures/tux_big/bigtux-star.sprite");
 141   airarrow.reset(new Surface("images/engine/hud/airarrow.png"));
 142
 143   sound_manager->preload("sounds/bigjump.wav");
 144   sound_manager->preload("sounds/jump.wav");
 145   sound_manager->preload("sounds/hurt.wav");
 146   sound_manager->preload("sounds/skid.wav");
 147   sound_manager->preload("sounds/flip.wav");
 148   sound_manager->preload("sounds/invincible.wav");
 149   sound_manager->preload("sounds/splash.ogg");
 150
 151   init();
 152 }
 153
 154 Player::~Player()
 155 {
 156   if (climbing) stop_climbing(*climbing);
 157   delete smalltux_gameover;
 158   delete smalltux_star;
 159   delete bigtux_star;
 160   delete scripting_controller;
 161 }
 162
 163 void
 164 Player::init()
 165 {
 166   if(is_big())
 167     set_size(31.8f, 62.8f);
 168   else
 169     set_size(31.8f, 30.8f);
 170
 171   dir = RIGHT;
 172   old_dir = dir;
 173   duck = false;
 174   dead = false;
 175
 176   dying = false;
 177   peeking = AUTO;
 178   last_ground_y = 0;
 179   fall_mode = ON_GROUND;
 180   jumping = false;
 181   can_jump = true;
 182   butt_jump = false;
 183   deactivated = false;
 184   backflipping = false;
 185   backflip_direction = 0;
 186   visible = true;
 187   swimming = false;
 188   speedlimit = 0; //no special limit
 189
 190   on_ground_flag = false;
 191   grabbed_object = NULL;
 192
 193   climbing = 0;
 194
 195   physic.reset();
 196 }
 197
 198 void
 199 Player::expose(HSQUIRRELVM vm, SQInteger table_idx)
 200 {
 201   if (name.empty())
 202     return;
 203
 204   Scripting::expose_object(vm, table_idx, dynamic_cast<Scripting::Player *>(this), name, false);
 205 }
 206
 207 void
 208 Player::unexpose(HSQUIRRELVM vm, SQInteger table_idx)
 209 {
 210   if (name.empty())
 211     return;
 212
 213   Scripting::unexpose_object(vm, table_idx, name);
 214 }
 215
 216 float
 217 Player::get_speedlimit()
 218 {
 219   return speedlimit;
 220 }
 221
 222 void
 223 Player::set_speedlimit(float newlimit)
 224 {
 225   speedlimit=newlimit;
 226 }
 227
 228 void
 229 Player::set_controller(Controller* controller)
 230 {
 231   this->controller = controller;
 232 }
 233
 234 void
 235 Player::use_scripting_controller(bool use_or_release)
 236 {
 237   if ((use_or_release == true) && (controller != scripting_controller)) {
 238     scripting_controller_old = get_controller();
 239     set_controller(scripting_controller);
 240   }
 241   if ((use_or_release == false) && (controller == scripting_controller)) {
 242     set_controller(scripting_controller_old);
 243     scripting_controller_old = 0;
 244   }
 245 }
 246
 247 void
 248 Player::do_scripting_controller(std::string control, bool pressed)
 249 {
 250   for(int i = 0; Controller::controlNames[i] != 0; ++i) {
 251     if(control == std::string(Controller::controlNames[i])) {
 252       scripting_controller->press(Controller::Control(i), pressed);
 253     }
 254   }
 255 }
 256
 257 bool
 258 Player::adjust_height(float new_height)
 259 {
 260   Rect bbox2 = bbox;
 261   bbox2.move(Vector(0, bbox.get_height() - new_height));
 262   bbox2.set_height(new_height);
 263
 264   if(new_height > bbox.get_height()) {
 265     Rect additional_space = bbox2;
 266     additional_space.set_height(new_height - bbox.get_height());
 267     if(!Sector::current()->is_free_of_statics(additional_space, this, true))
 268       return false;
 269   }
 270
 271   // adjust bbox accordingly
 272   // note that we use members of moving_object for this, so we can run this during CD, too
 273   set_pos(bbox2.p1);
 274   set_size(bbox2.get_width(), bbox2.get_height());
 275   return true;
 276 }
 277
 278 void
 279 Player::trigger_sequence(std::string sequence_name)
 280 {
 281   if (climbing) stop_climbing(*climbing);
 282   GameSession::current()->start_sequence(sequence_name);
 283 }
 284
 285 void
 286 Player::update(float elapsed_time)
 287 {
 288   if( no_water ){
 289     swimming = false;
 290   }
 291   no_water = true;
 292
 293   if(dying && dying_timer.check()) {
 294     dead = true;
 295     return;
 296   }
 297
 298   if(!dying && !deactivated)
 299     handle_input();
 300
 301   // handle_input() calls apply_friction() when Tux is not walking, so we'll have to do this ourselves
 302   if (deactivated)
 303     apply_friction();
 304
 305   // extend/shrink tux collision rectangle so that we fall through/walk over 1
 306   // tile holes
 307   if(fabsf(physic.get_velocity_x()) > MAX_WALK_XM) {
 308     set_width(34);
 309   } else {
 310     set_width(31.8f);
 311   }
 312
 313   // on downward slopes, adjust vertical velocity so tux walks smoothly down
 314   if (on_ground()) {
 315     if(floor_normal.y != 0) {
 316       if ((floor_normal.x * physic.get_velocity_x()) >= 0) {
 317         physic.set_velocity_y(250);
 318       }
 319     }
 320   }
 321
 322   // handle backflipping
 323   if (backflipping) {
 324     //prevent player from changing direction when backflipping
 325     dir = (backflip_direction == 1) ? LEFT : RIGHT;
 326     if (backflip_timer.started()) physic.set_velocity_x(100 * backflip_direction);
 327   }
 328
 329   // set fall mode...
 330   if(on_ground()) {
 331     fall_mode = ON_GROUND;
 332     last_ground_y = get_pos().y;
 333   } else {
 334     if(get_pos().y > last_ground_y)
 335       fall_mode = FALLING;
 336     else if(fall_mode == ON_GROUND)
 337       fall_mode = JUMPING;
 338   }
 339
 340   // check if we landed
 341   if(on_ground()) {
 342     jumping = false;
 343     if (backflipping && (!backflip_timer.started())) {
 344       backflipping = false;
 345       backflip_direction = 0;
 346
 347       // if controls are currently deactivated, we take care of standing up ourselves
 348       if (deactivated)
 349         do_standup();
 350     }
 351   }
 352
 353   // calculate movement for this frame
 354   movement = physic.get_movement(elapsed_time);
 355
 356   if(grabbed_object != NULL && !dying) {
 357     Vector pos = get_pos() +
 358       Vector(dir == LEFT ? -16 : 16, get_bbox().get_height()*0.66666 - 32);
 359     grabbed_object->grab(*this, pos, dir);
 360   }
 361
 362   if(grabbed_object != NULL && dying){
 363     grabbed_object->ungrab(*this, dir);
 364     grabbed_object = NULL;
 365   }
 366
 367   on_ground_flag = false;
 368
 369   // when invincible, spawn particles
 370   if (invincible_timer.started() && !dying)
 371   {
 372     if (systemRandom.rand(0, 2) == 0) {
 373       float px = systemRandom.randf(bbox.p1.x+0, bbox.p2.x-0);
 374       float py = systemRandom.randf(bbox.p1.y+0, bbox.p2.y-0);
 375       Vector ppos = Vector(px, py);
 376       Vector pspeed = Vector(0, 0);
 377       Vector paccel = Vector(0, 0);
 378       // draw bright sparkle when there is lots of time left, dark sparkle when invincibility is about to end
 379       if (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING) {
 380         // make every other a longer sparkle to make trail a bit fuzzy
 381         if (size_t(game_time*20)%2) {
 382           Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "small", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5));
 383         } else {
 384           Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "medium", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5));
 385         }
 386       } else {
 387         Sector::current()->add_object(new SpriteParticle("images/objects/particles/sparkle.sprite", "dark", ppos, ANCHOR_MIDDLE, pspeed, paccel, LAYER_OBJECTS+1+5));
 388       }
 389     }
 390   }
 391
 392 }
 393
 394 bool
 395 Player::on_ground()
 396 {
 397   return on_ground_flag;
 398 }
 399
 400 bool
 401 Player::is_big()
 402 {
 403   if(player_status->bonus == NO_BONUS)
 404     return false;
 405
 406   return true;
 407 }
 408
 409 void
 410 Player::apply_friction()
 411 {
 412   if ((on_ground()) && (fabs(physic.get_velocity_x()) < WALK_SPEED)) {
 413     physic.set_velocity_x(0);
 414     physic.set_acceleration_x(0);
 415   } else if(physic.get_velocity_x() < 0) {
 416     physic.set_acceleration_x(WALK_ACCELERATION_X * 1.5);
 417     } else if(physic.get_velocity_x() > 0) {
 418     physic.set_acceleration_x(WALK_ACCELERATION_X * -1.5);
 419   }
 420 }
 421
 422 void
 423 Player::handle_horizontal_input()
 424 {
 425   float vx = physic.get_velocity_x();
 426   float vy = physic.get_velocity_y();
 427   float ax = physic.get_acceleration_x();
 428   float ay = physic.get_acceleration_y();
 429
 430   float dirsign = 0;
 431   if(!duck || physic.get_velocity_y() != 0) {
 432     if(controller->hold(Controller::LEFT) && !controller->hold(Controller::RIGHT)) {
 433       old_dir = dir;
 434       dir = LEFT;
 435       dirsign = -1;
 436     } else if(!controller->hold(Controller::LEFT)
 437               && controller->hold(Controller::RIGHT)) {
 438       old_dir = dir;
 439       dir = RIGHT;
 440       dirsign = 1;
 441     }
 442   }
 443
 444   // do not run if action key is pressed or we're holding something
 445   // so tux can only walk while shooting
 446   if ( controller->hold(Controller::ACTION) || grabbed_object ) {
 447     ax = dirsign * WALK_ACCELERATION_X;
 448     // limit speed
 449     if(vx >= MAX_WALK_XM && dirsign > 0) {
 450       vx = MAX_WALK_XM;
 451       ax = 0;
 452     } else if(vx <= -MAX_WALK_XM && dirsign < 0) {
 453       vx = -MAX_WALK_XM;
 454       ax = 0;
 455     }
 456   } else {
 457     if( vx * dirsign < MAX_WALK_XM ) {
 458       ax = dirsign * WALK_ACCELERATION_X;
 459     } else {
 460       ax = dirsign * RUN_ACCELERATION_X;
 461     }
 462     // limit speed
 463     if(vx >= MAX_RUN_XM && dirsign > 0) {
 464       vx = MAX_RUN_XM;
 465       ax = 0;
 466     } else if(vx <= -MAX_RUN_XM && dirsign < 0) {
 467       vx = -MAX_RUN_XM;
 468       ax = 0;
 469     }
 470   }
 471
 472   // we can reach WALK_SPEED without any acceleration
 473   if(dirsign != 0 && fabs(vx) < WALK_SPEED) {
 474     vx = dirsign * WALK_SPEED;
 475   }
 476
 477   //Check speedlimit.
 478   if( speedlimit > 0 &&  vx * dirsign >= speedlimit ) {
 479       vx = dirsign * speedlimit;
 480       ax = 0;
 481   }
 482
 483   // changing directions?
 484   if(on_ground() && ((vx < 0 && dirsign >0) || (vx>0 && dirsign<0))) {
 485     // let's skid!
 486     if(fabs(vx)>SKID_XM && !skidding_timer.started()) {
 487       skidding_timer.start(SKID_TIME);
 488       sound_manager->play("sounds/skid.wav");
 489       // dust some particles
 490       Sector::current()->add_object(
 491         new Particles(
 492           Vector(dir == RIGHT ? get_bbox().p2.x : get_bbox().p1.x, get_bbox().p2.y),
 493           dir == RIGHT ? 270+20 : 90-40, dir == RIGHT ? 270+40 : 90-20,
 494           Vector(280, -260), Vector(0, 300), 3, Color(.4f, .4f, .4f), 3, .8f,
 495           LAYER_OBJECTS+1));
 496
 497       ax *= 2.5;
 498     } else {
 499       ax *= 2;
 500     }
 501   }
 502
 503   physic.set_velocity(vx, vy);
 504   physic.set_acceleration(ax, ay);
 505
 506   // we get slower when not pressing any keys
 507   if(dirsign == 0) {
 508     apply_friction();
 509   }
 510
 511 }
 512
 513 void
 514 Player::do_cheer()
 515 {
 516   do_duck();
 517   do_backflip();
 518   do_standup();
 519 }
 520
 521 void
 522 Player::do_duck() {
 523   if (duck)
 524     return;
 525   if (!is_big())
 526     return;
 527
 528   if (physic.get_velocity_y() != 0)
 529     return;
 530   if (!on_ground())
 531     return;
 532
 533   if (adjust_height(31.8f)) {
 534     duck = true;
 535     unduck_hurt_timer.stop();
 536   } else {
 537     // FIXME: what now?
 538   }
 539 }
 540
 541 void
 542 Player::do_standup() {
 543   if (!duck)
 544     return;
 545   if (!is_big())
 546     return;
 547   if (backflipping)
 548     return;
 549
 550   if (adjust_height(63.8f)) {
 551     duck = false;
 552     unduck_hurt_timer.stop();
 553   } else {
 554     // if timer is not already running, start it.
 555     if (unduck_hurt_timer.get_period() == 0) {
 556       unduck_hurt_timer.start(UNDUCK_HURT_TIME);
 557     }
 558     else if (unduck_hurt_timer.check()) {
 559       kill(false);
 560     }
 561   }
 562
 563 }
 564
 565 void
 566 Player::do_backflip() {
 567   if (!duck)
 568     return;
 569   if (!on_ground())
 570     return;
 571
 572   backflip_direction = (dir == LEFT)?(+1):(-1);
 573   backflipping = true;
 574   do_jump(-580);
 575   sound_manager->play("sounds/flip.wav");
 576   backflip_timer.start(0.15f);
 577 }
 578
 579 void
 580 Player::do_jump(float yspeed) {
 581   if (!on_ground())
 582     return;
 583
 584   physic.set_velocity_y(yspeed);
 585   //bbox.move(Vector(0, -1));
 586   jumping = true;
 587   on_ground_flag = false;
 588   can_jump = false;
 589
 590   // play sound
 591   if (is_big()) {
 592     sound_manager->play("sounds/bigjump.wav");
 593   } else {
 594     sound_manager->play("sounds/jump.wav");
 595   }
 596 }
 597
 598 void
 599 Player::handle_vertical_input()
 600 {
 601   // Press jump key
 602   if(controller->pressed(Controller::JUMP) && (can_jump)) {
 603     if (duck) {
 604       // when running, only jump a little bit; else do a backflip
 605       if ((physic.get_velocity_x() != 0) || (controller->hold(Controller::LEFT)) || (controller->hold(Controller::RIGHT))) do_jump(-300); else do_backflip();
 606     } else {
 607       // jump a bit higher if we are running; else do a normal jump
 608       if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) do_jump(-580); else do_jump(-520);
 609     }
 610   }
 611   // Let go of jump key
 612   else if(!controller->hold(Controller::JUMP)) {
 613     if (!backflipping && jumping && physic.get_velocity_y() < 0) {
 614       jumping = false;
 615       physic.set_velocity_y(0);
 616     }
 617   }
 618
 619   /* In case the player has pressed Down while in a certain range of air,
 620      enable butt jump action */
 621   if (controller->hold(Controller::DOWN) && !butt_jump && !duck && is_big() && jumping) {
 622     butt_jump = true;
 623   }
 624
 625   /* When Down is not held anymore, disable butt jump */
 626   if(butt_jump && !controller->hold(Controller::DOWN))
 627     butt_jump = false;
 628
 629   // swimming
 630   physic.set_acceleration_y(0);
 631 #ifdef SWIMMING
 632   if (swimming) {
 633     if (controller->hold(Controller::UP) || controller->hold(Controller::JUMP))
 634       physic.set_acceleration_y(-2000);
 635     physic.set_velocity_y(physic.get_velocity_y() * 0.94);
 636   }
 637 #endif
 638 }
 639
 640 void
 641 Player::handle_input()
 642 {
 643   if (ghost_mode) {
 644     handle_input_ghost();
 645     return;
 646   }
 647   if (climbing) {
 648     handle_input_climbing();
 649     return;
 650   }
 651
 652   /* Peeking */
 653   if( controller->released( Controller::PEEK_LEFT ) ) {
 654     peeking = AUTO;
 655   }
 656   if( controller->released( Controller::PEEK_RIGHT ) ) {
 657     peeking = AUTO;
 658   }
 659   if( controller->released( Controller::UP ) ) {
 660     peeking = AUTO;
 661   }
 662   if( controller->released( Controller::DOWN ) ) {
 663     peeking = AUTO;
 664   }
 665   if( controller->pressed( Controller::PEEK_LEFT ) ) {
 666     peeking = LEFT;
 667   }
 668   if( controller->pressed( Controller::PEEK_RIGHT ) ) {
 669     peeking = RIGHT;
 670   }
 671   if( controller->pressed( Controller::UP ) ) {
 672     peeking = UP;
 673   }
 674   if( controller->pressed( Controller::DOWN ) ) {
 675     peeking = DOWN;
 676   }
 677
 678   /* Handle horizontal movement: */
 679   if (!backflipping) handle_horizontal_input();
 680
 681   /* Jump/jumping? */
 682   if (on_ground() && !controller->hold(Controller::JUMP))
 683     can_jump = true;
 684
 685   /* Handle vertical movement: */
 686   handle_vertical_input();
 687
 688   /* Shoot! */
 689   if (controller->pressed(Controller::ACTION) && (player_status->bonus == FIRE_BONUS || player_status->bonus == ICE_BONUS)) {
 690     if(Sector::current()->add_bullet(
 691          get_pos() + ((dir == LEFT)? Vector(0, bbox.get_height()/2)
 692                       : Vector(32, bbox.get_height()/2)),
 693          physic.get_velocity_x(), dir))
 694       shooting_timer.start(SHOOTING_TIME);
 695   }
 696
 697   /* Duck or Standup! */
 698   if (controller->hold(Controller::DOWN)) {
 699     do_duck();
 700   } else {
 701     do_standup();
 702   }
 703
 704   /* grabbing */
 705   try_grab();
 706
 707   if(!controller->hold(Controller::ACTION) && grabbed_object) {
 708     // move the grabbed object a bit away from tux
 709     Vector pos = get_pos() +
 710         Vector(dir == LEFT ? -bbox.get_width()-1 : bbox.get_width()+1,
 711                 bbox.get_height()*0.66666 - 32);
 712     Rect dest(pos, pos + Vector(32, 32));
 713     if(Sector::current()->is_free_of_movingstatics(dest)) {
 714       MovingObject* moving_object = dynamic_cast<MovingObject*> (grabbed_object);
 715       if(moving_object) {
 716         moving_object->set_pos(pos);
 717       } else {
 718         log_debug << "Non MovingObject grabbed?!?" << std::endl;
 719       }
 720       if(controller->hold(Controller::UP)) {
 721         grabbed_object->ungrab(*this, UP);
 722       } else {
 723         grabbed_object->ungrab(*this, dir);
 724       }
 725       grabbed_object = NULL;
 726     }
 727   }
 728 }
 729
 730 void
 731 Player::try_grab()
 732 {
 733   if(controller->hold(Controller::ACTION) && !grabbed_object
 734       && !duck) {
 735   Sector* sector = Sector::current();
 736     Vector pos;
 737     if(dir == LEFT) {
 738       pos = Vector(bbox.get_left() - 5, bbox.get_bottom() - 16);
 739     } else {
 740       pos = Vector(bbox.get_right() + 5, bbox.get_bottom() - 16);
 741     }
 742
 743     for(Sector::Portables::iterator i = sector->portables.begin();
 744         i != sector->portables.end(); ++i) {
 745       Portable* portable = *i;
 746       if(!portable->is_portable())
 747         continue;
 748
 749       // make sure the Portable is a MovingObject
 750       MovingObject* moving_object = dynamic_cast<MovingObject*> (portable);
 751       assert(moving_object);
 752       if(moving_object == NULL)
 753         continue;
 754
 755       // make sure the Portable isn't currently non-solid
 756       if(moving_object->get_group() == COLGROUP_DISABLED) continue;
 757
 758       // check if we are within reach
 759       if(moving_object->get_bbox().contains(pos)) {
 760         if (climbing) stop_climbing(*climbing);
 761         grabbed_object = portable;
 762         grabbed_object->grab(*this, get_pos(), dir);
 763         break;
 764       }
 765     }
 766   }
 767 }
 768
 769 void
 770 Player::handle_input_ghost()
 771 {
 772   float vx = 0;
 773   float vy = 0;
 774   if (controller->hold(Controller::LEFT)) {
 775     dir = LEFT;
 776     vx -= MAX_RUN_XM * 2;
 777   }
 778   if (controller->hold(Controller::RIGHT)) {
 779     dir = RIGHT;
 780     vx += MAX_RUN_XM * 2;
 781   }
 782   if ((controller->hold(Controller::UP)) || (controller->hold(Controller::JUMP))) {
 783     vy -= MAX_RUN_XM * 2;
 784   }
 785   if (controller->hold(Controller::DOWN)) {
 786     vy += MAX_RUN_XM * 2;
 787   }
 788   if (controller->hold(Controller::ACTION)) {
 789     set_ghost_mode(false);
 790   }
 791   physic.set_velocity(vx, vy);
 792   physic.set_acceleration(0, 0);
 793 }
 794
 795 void
 796 Player::add_coins(int count)
 797 {
 798   player_status->add_coins(count);
 799 }
 800
 801 int
 802 Player::get_coins()
 803 {
 804   return player_status->coins;
 805 }
 806
 807 bool
 808 Player::add_bonus(const std::string& bonustype)
 809 {
 810   BonusType type = NO_BONUS;
 811
 812   if(bonustype == "grow") {
 813     type = GROWUP_BONUS;
 814   } else if(bonustype == "fireflower") {
 815     type = FIRE_BONUS;
 816   } else if(bonustype == "iceflower") {
 817     type = ICE_BONUS;
 818   } else if(bonustype == "none") {
 819     type = NO_BONUS;
 820   } else {
 821     std::ostringstream msg;
 822     msg << "Unknown bonus type "  << bonustype;
 823     throw std::runtime_error(msg.str());
 824   }
 825
 826   return add_bonus(type);
 827 }
 828
 829 bool
 830 Player::add_bonus(BonusType type, bool animate)
 831 {
 832   // always ignore NO_BONUS
 833   if (type == NO_BONUS) {
 834     return true;
 835   }
 836
 837   // ignore GROWUP_BONUS if we're already big
 838   if (type == GROWUP_BONUS) {
 839     if (player_status->bonus == GROWUP_BONUS)
 840       return true;
 841     if (player_status->bonus == FIRE_BONUS)
 842       return true;
 843     if (player_status->bonus == ICE_BONUS)
 844       return true;
 845   }
 846
 847   return set_bonus(type, animate);
 848 }
 849
 850 bool
 851 Player::set_bonus(BonusType type, bool animate)
 852 {
 853   if(player_status->bonus == NO_BONUS) {
 854     if (!adjust_height(62.8f)) {
 855       printf("can't adjust\n");
 856       return false;
 857     }
 858     if(animate)
 859       growing_timer.start(GROWING_TIME);
 860     if (climbing) stop_climbing(*climbing);
 861   }
 862
 863   if ((type == NO_BONUS) || (type == GROWUP_BONUS)) {
 864     if ((player_status->bonus == FIRE_BONUS) && (animate)) {
 865       // visually lose helmet
 866       Vector ppos = Vector((bbox.p1.x + bbox.p2.x) / 2, bbox.p1.y);
 867       Vector pspeed = Vector(((dir==LEFT) ? +100 : -100), -300);
 868       Vector paccel = Vector(0, 1000);
 869       std::string action = (dir==LEFT)?"left":"right";
 870       Sector::current()->add_object(new SpriteParticle("images/objects/particles/firetux-helmet.sprite", action, ppos, ANCHOR_TOP, pspeed, paccel, LAYER_OBJECTS-1));
 871       if (climbing) stop_climbing(*climbing);
 872     }
 873     if ((player_status->bonus == ICE_BONUS) && (animate)) {
 874       // visually lose cap
 875       Vector ppos = Vector((bbox.p1.x + bbox.p2.x) / 2, bbox.p1.y);
 876       Vector pspeed = Vector(((dir==LEFT) ? +100 : -100), -300);
 877       Vector paccel = Vector(0, 1000);
 878       std::string action = (dir==LEFT)?"left":"right";
 879       Sector::current()->add_object(new SpriteParticle("images/objects/particles/icetux-cap.sprite", action, ppos, ANCHOR_TOP, pspeed, paccel, LAYER_OBJECTS-1));
 880       if (climbing) stop_climbing(*climbing);
 881     }
 882     player_status->max_fire_bullets = 0;
 883     player_status->max_ice_bullets = 0;
 884   }
 885   if (type == FIRE_BONUS) player_status->max_fire_bullets++;
 886   if (type == ICE_BONUS) player_status->max_ice_bullets++;
 887
 888   player_status->bonus = type;
 889   return true;
 890 }
 891
 892 void
 893 Player::set_visible(bool visible)
 894 {
 895   this->visible = visible;
 896   if( visible )
 897     set_group(COLGROUP_MOVING);
 898   else
 899     set_group(COLGROUP_DISABLED);
 900 }
 901
 902 bool
 903 Player::get_visible()
 904 {
 905   return visible;
 906 }
 907
 908 void
 909 Player::kick()
 910 {
 911   kick_timer.start(KICK_TIME);
 912 }
 913
 914 void
 915 Player::draw(DrawingContext& context)
 916 {
 917   if(!visible)
 918     return;
 919
 920   // if Tux is above camera, draw little "air arrow" to show where he is x-wise
 921   if (Sector::current() && Sector::current()->camera && (get_bbox().p2.y - 16 < Sector::current()->camera->get_translation().y)) {
 922     float px = get_pos().x + (get_bbox().p2.x - get_bbox().p1.x - airarrow.get()->get_width()) / 2;
 923     float py = Sector::current()->camera->get_translation().y;
 924     py += std::min(((py - (get_bbox().p2.y + 16)) / 4), 16.0f);
 925     context.draw_surface(airarrow.get(), Vector(px, py), LAYER_HUD - 1);
 926   }
 927
 928   TuxBodyParts* tux_body;
 929
 930   if (player_status->bonus == GROWUP_BONUS)
 931     tux_body = big_tux;
 932   else if (player_status->bonus == FIRE_BONUS)
 933     tux_body = fire_tux;
 934   else if (player_status->bonus == ICE_BONUS)
 935     tux_body = ice_tux;
 936   else
 937     tux_body = small_tux;
 938
 939   int layer = LAYER_OBJECTS + 1;
 940
 941   /* Set Tux sprite action */
 942   if (climbing)
 943     {
 944     tux_body->set_action("skid-left");
 945     }
 946   else if (backflipping)
 947     {
 948     if(dir == LEFT)
 949       tux_body->set_action("backflip-left");
 950     else // dir == RIGHT
 951       tux_body->set_action("backflip-right");
 952     }
 953   else if (duck && is_big())
 954     {
 955     if(dir == LEFT)
 956       tux_body->set_action("duck-left");
 957     else // dir == RIGHT
 958       tux_body->set_action("duck-right");
 959     }
 960   else if (skidding_timer.started() && !skidding_timer.check())
 961     {
 962     if(dir == LEFT)
 963       tux_body->set_action("skid-left");
 964     else // dir == RIGHT
 965       tux_body->set_action("skid-right");
 966     }
 967   else if (kick_timer.started() && !kick_timer.check())
 968     {
 969     if(dir == LEFT)
 970       tux_body->set_action("kick-left");
 971     else // dir == RIGHT
 972       tux_body->set_action("kick-right");
 973     }
 974   else if (butt_jump && is_big())
 975     {
 976     if(dir == LEFT)
 977       tux_body->set_action("buttjump-left");
 978     else // dir == RIGHT
 979       tux_body->set_action("buttjump-right");
 980     }
 981   else if (!on_ground())
 982     {
 983     if(dir == LEFT)
 984       tux_body->set_action("jump-left");
 985     else // dir == RIGHT
 986       tux_body->set_action("jump-right");
 987     }
 988   else
 989     {
 990     if (fabsf(physic.get_velocity_x()) < 1.0f) // standing
 991       {
 992       if(dir == LEFT)
 993         tux_body->set_action("stand-left");
 994       else // dir == RIGHT
 995         tux_body->set_action("stand-right");
 996       }
 997     else // moving
 998       {
 999       if(dir == LEFT)
1000         tux_body->set_action("walk-left");
1001       else // dir == RIGHT
1002         tux_body->set_action("walk-right");
1003       }
1004     }
1005
1006   if(idle_timer.check())
1007     {
1008     if(is_big())
1009       {
1010       if(dir == LEFT)
1011         tux_body->head->set_action("idle-left", 1);
1012       else // dir == RIGHT
1013         tux_body->head->set_action("idle-right", 1);
1014       }
1015
1016     }
1017
1018   // Tux is holding something
1019   if ((grabbed_object != 0 && physic.get_velocity_y() == 0) ||
1020       (shooting_timer.get_timeleft() > 0 && !shooting_timer.check()))
1021     {
1022     if (duck)
1023       {
1024       if(dir == LEFT)
1025         tux_body->arms->set_action("duck+grab-left");
1026       else // dir == RIGHT
1027         tux_body->arms->set_action("duck+grab-right");
1028       }
1029     else
1030       {
1031       if(dir == LEFT)
1032         tux_body->arms->set_action("grab-left");
1033       else // dir == RIGHT
1034         tux_body->arms->set_action("grab-right");
1035       }
1036     }
1037
1038   /* Draw Tux */
1039   if(dying) {
1040     smalltux_gameover->draw(context, get_pos(), LAYER_FLOATINGOBJECTS + 1);
1041   }
1042   else if ((growing_timer.get_timeleft() > 0) && (!duck)) {
1043       if (dir == RIGHT) {
1044         context.draw_surface(growingtux_right[int((growing_timer.get_timegone() *
1045                  GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
1046       } else {
1047         context.draw_surface(growingtux_left[int((growing_timer.get_timegone() *
1048                 GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
1049       }
1050     }
1051   else if (safe_timer.started() && size_t(game_time*40)%2)
1052     ;  // don't draw Tux
1053   else
1054     tux_body->draw(context, get_pos(), layer, grabbed_object);
1055
1056 }
1057
1058 void
1059 Player::collision_tile(uint32_t tile_attributes)
1060 {
1061   if(tile_attributes & Tile::HURTS)
1062     kill(false);
1063
1064 #ifdef SWIMMING
1065   if( swimming ){
1066     if( tile_attributes & Tile::WATER ){
1067       no_water = false;
1068     } else {
1069       swimming = false;
1070     }
1071   } else {
1072     if( tile_attributes & Tile::WATER ){
1073       swimming = true;
1074       no_water = false;
1075       sound_manager->play( "sounds/splash.ogg" );
1076     }
1077   }
1078 #endif
1079 }
1080
1081 void
1082 Player::collision_solid(const CollisionHit& hit)
1083 {
1084   if(hit.bottom) {
1085     if(physic.get_velocity_y() > 0)
1086       physic.set_velocity_y(0);
1087
1088     on_ground_flag = true;
1089     floor_normal = hit.slope_normal;
1090   } else if(hit.top) {
1091     if(physic.get_velocity_y() < 0)
1092       physic.set_velocity_y(.2f);
1093   }
1094
1095   if(hit.left || hit.right) {
1096     physic.set_velocity_x(0);
1097   }
1098
1099   // crushed?
1100   if(hit.crush) {
1101     if(hit.left || hit.right) {
1102       kill(true);
1103     } else if(hit.top || hit.bottom) {
1104       kill(false);
1105     }
1106   }
1107 }
1108
1109 HitResponse
1110 Player::collision(GameObject& other, const CollisionHit& hit)
1111 {
1112   Bullet* bullet = dynamic_cast<Bullet*> (&other);
1113   if(bullet) {
1114     return FORCE_MOVE;
1115   }
1116
1117   if(hit.left || hit.right) {
1118     try_grab(); //grab objects right now, in update it will be too late
1119   }
1120 #ifdef DEBUG
1121   assert(dynamic_cast<MovingObject*> (&other) != NULL);
1122 #endif
1123   MovingObject* moving_object = static_cast<MovingObject*> (&other);
1124   if(moving_object->get_group() == COLGROUP_TOUCHABLE) {
1125     TriggerBase* trigger = dynamic_cast<TriggerBase*> (&other);
1126     if(trigger) {
1127       if(controller->pressed(Controller::UP))
1128         trigger->event(*this, TriggerBase::EVENT_ACTIVATE);
1129     }
1130
1131     return FORCE_MOVE;
1132   }
1133
1134   BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
1135   if(badguy != NULL) {
1136     if(safe_timer.started() || invincible_timer.started())
1137       return FORCE_MOVE;
1138
1139     return CONTINUE;
1140   }
1141
1142   return CONTINUE;
1143 }
1144
1145 void
1146 Player::make_invincible()
1147 {
1148   sound_manager->play("sounds/invincible.wav");
1149   invincible_timer.start(TUX_INVINCIBLE_TIME);
1150   Sector::current()->play_music(HERRING_MUSIC);
1151 }
1152
1153 /* Kill Player! */
1154 void
1155 Player::kill(bool completely)
1156 {
1157   if(dying || deactivated)
1158     return;
1159
1160   if(!completely && (safe_timer.started() || invincible_timer.started()))
1161     return;
1162
1163   sound_manager->play("sounds/hurt.wav");
1164
1165   if (climbing) stop_climbing(*climbing);
1166
1167   physic.set_velocity_x(0);
1168
1169   if(!completely && (is_big() || growing_timer.started())) {
1170     if(player_status->bonus == FIRE_BONUS
1171         || player_status->bonus == ICE_BONUS) {
1172       safe_timer.start(TUX_SAFE_TIME);
1173       set_bonus(GROWUP_BONUS, true);
1174     } else if(player_status->bonus == GROWUP_BONUS) {
1175       //growing_timer.start(GROWING_TIME);
1176       safe_timer.start(TUX_SAFE_TIME /* + GROWING_TIME */);
1177       adjust_height(30.8f);
1178       duck = false;
1179       set_bonus(NO_BONUS, true);
1180     } else if(player_status->bonus == NO_BONUS) {
1181       growing_timer.stop();
1182       safe_timer.start(TUX_SAFE_TIME);
1183       adjust_height(30.8f);
1184       duck = false;
1185     }
1186   } else {
1187
1188     // do not die when in edit mode
1189     if (edit_mode) {
1190       set_ghost_mode(true);
1191       return;
1192     }
1193
1194     if (player_status->coins >= 25 && !GameSession::current()->get_reset_point_sectorname().empty())
1195     {
1196       for (int i = 0; i < 5; i++)
1197       {
1198         // the numbers: starting x, starting y, velocity y
1199         Sector::current()->add_object(new FallingCoin(get_pos() +
1200               Vector(systemRandom.rand(5), systemRandom.rand(-32,18)),
1201               systemRandom.rand(-100,100)));
1202       }
1203       player_status->coins -= std::max(player_status->coins/10, 25);
1204     }
1205     else
1206     {
1207       GameSession::current()->set_reset_point("", Vector());
1208     }
1209     physic.enable_gravity(true);
1210     physic.set_acceleration(0, 0);
1211     physic.set_velocity(0, -700);
1212     set_bonus(NO_BONUS, true);
1213     dying = true;
1214     dying_timer.start(3.0);
1215     set_group(COLGROUP_DISABLED);
1216
1217     DisplayEffect* effect = new DisplayEffect();
1218     effect->fade_out(3.0);
1219     Sector::current()->add_object(effect);
1220     sound_manager->stop_music(3.0);
1221   }
1222 }
1223
1224 void
1225 Player::move(const Vector& vector)
1226 {
1227   set_pos(vector);
1228
1229   // TODO: do we need the following? Seems irrelevant to moving the player
1230   if(is_big())
1231     set_size(31.8f, 63.8f);
1232   else
1233     set_size(31.8f, 31.8f);
1234   duck = false;
1235   last_ground_y = vector.y;
1236   if (climbing) stop_climbing(*climbing);
1237
1238   physic.reset();
1239 }
1240
1241 void
1242 Player::check_bounds(Camera* camera)
1243 {
1244   /* Keep tux in bounds: */
1245   if (get_pos().x < 0) {
1246     // Lock Tux to the size of the level, so that he doesn't fall of
1247     // on the left side
1248     set_pos(Vector(0, get_pos().y));
1249   }
1250
1251   /* fallen out of the level? */
1252   if ((get_pos().y > Sector::current()->get_height()) && (!ghost_mode)) {
1253     kill(true);
1254     return;
1255   }
1256
1257   // can happen if back scrolling is disabled
1258   if(get_pos().x < camera->get_translation().x) {
1259     set_pos(Vector(camera->get_translation().x, get_pos().y));
1260   }
1261   if(get_pos().x >= camera->get_translation().x + SCREEN_WIDTH - bbox.get_width())
1262   {
1263     set_pos(Vector(
1264           camera->get_translation().x + SCREEN_WIDTH - bbox.get_width(),
1265           get_pos().y));
1266   }
1267 }
1268
1269 void
1270 Player::add_velocity(const Vector& velocity)
1271 {
1272   physic.set_velocity(physic.get_velocity() + velocity);
1273 }
1274
1275 void
1276 Player::add_velocity(const Vector& velocity, const Vector& end_speed)
1277 {
1278   if (end_speed.x > 0)
1279     physic.set_velocity_x(std::min(physic.get_velocity_x() + velocity.x, end_speed.x));
1280   if (end_speed.x < 0)
1281     physic.set_velocity_x(std::max(physic.get_velocity_x() + velocity.x, end_speed.x));
1282   if (end_speed.y > 0)
1283     physic.set_velocity_y(std::min(physic.get_velocity_y() + velocity.y, end_speed.y));
1284   if (end_speed.y < 0)
1285     physic.set_velocity_y(std::max(physic.get_velocity_y() + velocity.y, end_speed.y));
1286 }
1287
1288 void
1289 Player::bounce(BadGuy& )
1290 {
1291   if(controller->hold(Controller::JUMP))
1292     physic.set_velocity_y(-520);
1293   else
1294     physic.set_velocity_y(-300);
1295 }
1296
1297 //Scripting Functions Below
1298
1299 void
1300 Player::deactivate()
1301 {
1302   if (deactivated)
1303     return;
1304   deactivated = true;
1305   physic.set_velocity_x(0);
1306   physic.set_velocity_y(0);
1307   physic.set_acceleration_x(0);
1308   physic.set_acceleration_y(0);
1309   if (climbing) stop_climbing(*climbing);
1310 }
1311
1312 void
1313 Player::activate()
1314 {
1315   if (!deactivated)
1316     return;
1317   deactivated = false;
1318 }
1319
1320 void Player::walk(float speed)
1321 {
1322   physic.set_velocity_x(speed);
1323 }
1324
1325 void
1326 Player::set_ghost_mode(bool enable)
1327 {
1328   if (ghost_mode == enable)
1329     return;
1330
1331   if (climbing) stop_climbing(*climbing);
1332
1333   if (enable) {
1334     ghost_mode = true;
1335     set_group(COLGROUP_DISABLED);
1336     physic.enable_gravity(false);
1337     log_debug << "You feel lightheaded. Use movement controls to float around, press ACTION to scare badguys." << std::endl;
1338   } else {
1339     ghost_mode = false;
1340     set_group(COLGROUP_MOVING);
1341     physic.enable_gravity(true);
1342     log_debug << "You feel solid again." << std::endl;
1343   }
1344 }
1345
1346
1347 void
1348 Player::set_edit_mode(bool enable)
1349 {
1350   edit_mode = enable;
1351 }
1352
1353 void
1354 Player::start_climbing(Climbable& climbable)
1355 {
1356   if (climbing == &climbable) return;
1357
1358   climbing = &climbable;
1359   physic.enable_gravity(false);
1360   physic.set_velocity(0, 0);
1361   physic.set_acceleration(0, 0);
1362 }
1363
1364 void
1365 Player::stop_climbing(Climbable& /*climbable*/)
1366 {
1367   if (!climbing) return;
1368
1369   climbing = 0;
1370
1371   if (grabbed_object) {
1372     grabbed_object->ungrab(*this, dir);
1373     grabbed_object = NULL;
1374   }
1375
1376   physic.enable_gravity(true);
1377   physic.set_velocity(0, 0);
1378   physic.set_acceleration(0, 0);
1379
1380   if ((controller->hold(Controller::JUMP)) || (controller->hold(Controller::UP))) {
1381     on_ground_flag = true;
1382     // TODO: This won't help. Why?
1383     do_jump(-300);
1384   }
1385 }
1386
1387 void
1388 Player::handle_input_climbing()
1389 {
1390   if (!climbing) {
1391     log_warning << "handle_input_climbing called with climbing set to 0. Input handling skipped" << std::endl;
1392     return;
1393   }
1394
1395   float vx = 0;
1396   float vy = 0;
1397   if (controller->hold(Controller::LEFT)) {
1398     dir = LEFT;
1399     vx -= MAX_CLIMB_XM;
1400   }
1401   if (controller->hold(Controller::RIGHT)) {
1402     dir = RIGHT;
1403     vx += MAX_CLIMB_XM;
1404   }
1405   if (controller->hold(Controller::UP)) {
1406     vy -= MAX_CLIMB_YM;
1407   }
1408   if (controller->hold(Controller::DOWN)) {
1409     vy += MAX_CLIMB_YM;
1410   }
1411   if (controller->hold(Controller::JUMP)) {
1412     if (can_jump) {
1413       stop_climbing(*climbing);
1414       return;
1415     }
1416   } else {
1417     can_jump = true;
1418   }
1419   if (controller->hold(Controller::ACTION)) {
1420     stop_climbing(*climbing);
1421     return;
1422   }
1423   physic.set_velocity(vx, vy);
1424   physic.set_acceleration(0, 0);
1425 }
1426
1427