src/object/player.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux -  A Jump'n Run
   4 //  Copyright (C) 2003 Tobias Glaesser <tobi.web@gmx.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 "video/screen.hpp"
  35 #include "statistics.hpp"
  36 #include "game_session.hpp"
  37 #include "object/tilemap.hpp"
  38 #include "object/camera.hpp"
  39 #include "object/particles.hpp"
  40 #include "object/portable.hpp"
  41 #include "object/bullet.hpp"
  42 #include "trigger/trigger_base.hpp"
  43 #include "control/joystickkeyboardcontroller.hpp"
  44 #include "main.hpp"
  45 #include "badguy/badguy.hpp"
  46 #include "player_status.hpp"
  47 #include "msg.hpp"
  48
  49 static const int TILES_FOR_BUTTJUMP = 3;
  50 static const float SHOOTING_TIME = .150;
  51 /// time before idle animation starts
  52 static const float IDLE_TIME = 2.5;
  53
  54 static const float WALK_ACCELERATION_X = 300;
  55 static const float RUN_ACCELERATION_X = 400;
  56 static const float SKID_XM = 200;
  57 static const float SKID_TIME = .3;
  58 static const float MAX_WALK_XM = 230;
  59 static const float MAX_RUN_XM = 320;
  60 static const float WALK_SPEED = 100;
  61
  62 static const float KICK_TIME = .3;
  63
  64 // growing animation
  65 Surface* growingtux_left[GROWING_FRAMES];
  66 Surface* growingtux_right[GROWING_FRAMES];
  67
  68 Surface* tux_life = 0;
  69
  70 TuxBodyParts* small_tux = 0;
  71 TuxBodyParts* big_tux = 0;
  72 TuxBodyParts* fire_tux = 0;
  73 TuxBodyParts* ice_tux = 0;
  74
  75 void
  76 TuxBodyParts::set_action(std::string action, int loops)
  77 {
  78   if(head != NULL)
  79     head->set_action(action, loops);
  80   if(body != NULL)
  81     body->set_action(action, loops);
  82   if(arms != NULL)
  83     arms->set_action(action, loops);
  84   if(feet != NULL)
  85     feet->set_action(action, loops);
  86 }
  87
  88 void
  89 TuxBodyParts::draw(DrawingContext& context, const Vector& pos, int layer)
  90 {
  91   if(head != NULL)
  92     head->draw(context, pos, layer-1);
  93   if(body != NULL)
  94     body->draw(context, pos, layer-3);
  95   if(arms != NULL)
  96     arms->draw(context, pos, layer);
  97   if(feet != NULL)
  98     feet->draw(context, pos, layer-2);
  99 }
 100
 101 Player::Player(PlayerStatus* _player_status)
 102   : player_status(_player_status), grabbed_object(0)
 103 {
 104   controller = main_controller;
 105   smalltux_gameover = sprite_manager->create("images/creatures/tux_small/smalltux-gameover.sprite");
 106   smalltux_star = sprite_manager->create("images/creatures/tux_small/smalltux-star.sprite");
 107   bigtux_star = sprite_manager->create("images/creatures/tux_big/bigtux-star.sprite");
 108   init();
 109 }
 110
 111 Player::~Player()
 112 {
 113   delete smalltux_gameover;
 114   delete smalltux_star;
 115   delete bigtux_star;
 116 }
 117
 118 void
 119 Player::init()
 120 {
 121   if(is_big())
 122     bbox.set_size(31.8, 63.8);
 123   else
 124     bbox.set_size(31.8, 31.8);
 125
 126   dir = RIGHT;
 127   old_dir = dir;
 128   duck = false;
 129   dead = false;
 130
 131   dying = false;
 132   last_ground_y = 0;
 133   fall_mode = ON_GROUND;
 134   jumping = false;
 135   can_jump = true;
 136   butt_jump = false;
 137   deactivated = false;
 138   backflipping = false;
 139   backflip_direction = 0;
 140   visible = true;
 141
 142   on_ground_flag = false;
 143   grabbed_object = 0;
 144
 145   floor_normal = Vector(0,-1);
 146
 147   physic.reset();
 148 }
 149
 150 void
 151 Player::set_controller(Controller* controller)
 152 {
 153   this->controller = controller;
 154 }
 155
 156 void
 157 Player::update(float elapsed_time)
 158 {
 159   // do we need to enable gravity again?
 160   if(on_ground_flag) {
 161     Rect lower = bbox;
 162     lower.move(Vector(0, 4.0));
 163     if(Sector::current()->is_free_space(lower)) {
 164       physic.enable_gravity(true);
 165       on_ground_flag = false;
 166     }
 167   }
 168
 169   if(dying && dying_timer.check()) {
 170     dead = true;
 171     return;
 172   }
 173
 174   if(!controller->hold(Controller::ACTION) && grabbed_object) {
 175     // move the grabbed object a bit away from tux
 176     Vector pos = get_pos() +
 177         Vector(dir == LEFT ? -bbox.get_width()-1 : bbox.get_width()+1,
 178                 bbox.get_height()*0.66666 - 32);
 179     Rect dest(pos, pos + Vector(32, 32));
 180     if(Sector::current()->is_free_space(dest)) {
 181       MovingObject* moving_object = dynamic_cast<MovingObject*> (grabbed_object);
 182       if(moving_object) {
 183         moving_object->set_pos(pos);
 184       } else {
 185         msg_debug("Non MovingObjetc grabbed?!?");
 186       }
 187       grabbed_object->ungrab(*this, dir);
 188       grabbed_object = 0;
 189     }
 190   }
 191
 192   if(!dying && !deactivated)
 193     handle_input();
 194
 195   movement = physic.get_movement(elapsed_time);
 196
 197 #if 0
 198   // special exception for cases where we're stuck under tiles after
 199   // being ducked. In this case we drift out
 200   if(!duck && on_ground() && old_base.x == base.x && old_base.y == base.y
 201      && collision_object_map(base)) {
 202     base.x += elapsed_time * WALK_SPEED * (dir ? 1: -1);
 203     previous_base = old_base = base;
 204   }
 205 #endif
 206
 207   if(grabbed_object != 0) {
 208     Vector pos = get_pos() +
 209       Vector(dir == LEFT ? -16 : 16,
 210              bbox.get_height()*0.66666 - 32);
 211     grabbed_object->grab(*this, pos, dir);
 212   }
 213 }
 214
 215 bool
 216 Player::on_ground()
 217 {
 218   return on_ground_flag;
 219 }
 220
 221 bool
 222 Player::is_big()
 223 {
 224   if(player_status->bonus == NO_BONUS)
 225     return false;
 226
 227   return true;
 228 }
 229
 230 void
 231 Player::handle_horizontal_input()
 232 {
 233   float vx = physic.get_velocity_x();
 234   float vy = physic.get_velocity_y();
 235   float ax = physic.get_acceleration_x();
 236   float ay = physic.get_acceleration_y();
 237
 238   float dirsign = 0;
 239   if(!duck || physic.get_velocity_y() != 0) {
 240     if(controller->hold(Controller::LEFT) && !controller->hold(Controller::RIGHT)) {
 241       old_dir = dir;
 242       dir = LEFT;
 243       dirsign = -1;
 244     } else if(!controller->hold(Controller::LEFT)
 245               && controller->hold(Controller::RIGHT)) {
 246       old_dir = dir;
 247       dir = RIGHT;
 248       dirsign = 1;
 249     }
 250   }
 251
 252   if (!controller->hold(Controller::ACTION)) {
 253     ax = dirsign * WALK_ACCELERATION_X;
 254     // limit speed
 255     if(vx >= MAX_WALK_XM && dirsign > 0) {
 256       vx = MAX_WALK_XM;
 257       ax = 0;
 258     } else if(vx <= -MAX_WALK_XM && dirsign < 0) {
 259       vx = -MAX_WALK_XM;
 260       ax = 0;
 261     }
 262   } else {
 263     ax = dirsign * RUN_ACCELERATION_X;
 264     // limit speed
 265     if(vx >= MAX_RUN_XM && dirsign > 0) {
 266       vx = MAX_RUN_XM;
 267       ax = 0;
 268     } else if(vx <= -MAX_RUN_XM && dirsign < 0) {
 269       vx = -MAX_RUN_XM;
 270       ax = 0;
 271     }
 272   }
 273
 274   // we can reach WALK_SPEED without any acceleration
 275   if(dirsign != 0 && fabs(vx) < WALK_SPEED) {
 276     vx = dirsign * WALK_SPEED;
 277   }
 278
 279   // changing directions?
 280   if(on_ground() && ((vx < 0 && dirsign >0) || (vx>0 && dirsign<0))) {
 281     // let's skid!
 282     if(fabs(vx)>SKID_XM && !skidding_timer.started()) {
 283       skidding_timer.start(SKID_TIME);
 284       sound_manager->play("sounds/skid.wav");
 285       // dust some particles
 286       Sector::current()->add_object(
 287         new Particles(
 288           Vector(dir == RIGHT ? bbox.p2.x : bbox.p1.x, bbox.p2.y),
 289           dir == RIGHT ? 270+20 : 90-40, dir == RIGHT ? 270+40 : 90-20,
 290           Vector(280, -260), Vector(0, 300), 3, Color(.4, .4, .4), 3, .8,
 291           LAYER_OBJECTS+1));
 292
 293       ax *= 2.5;
 294     } else {
 295       ax *= 2;
 296     }
 297   }
 298
 299   // we get slower when not pressing any keys
 300   if(dirsign == 0) {
 301     if(fabs(vx) < WALK_SPEED) {
 302       vx = 0;
 303       ax = 0;
 304     } else if(vx < 0) {
 305       ax = WALK_ACCELERATION_X * 1.5;
 306     } else {
 307       ax = WALK_ACCELERATION_X * -1.5;
 308     }
 309   }
 310
 311 #if 0
 312   // if we're on ice slow down acceleration or deceleration
 313   if (isice(base.x, base.y + base.height))
 314   {
 315     /* the acceleration/deceleration rate on ice is inversely proportional to
 316      * the current velocity.
 317      */
 318
 319     // increasing 1 will increase acceleration/deceleration rate
 320     // decreasing 1 will decrease acceleration/deceleration rate
 321     //  must stay above zero, though
 322     if (ax != 0) ax *= 1 / fabs(vx);
 323   }
 324 #endif
 325
 326   // extend/shrink tux collision rectangle so that we fall through/walk over 1
 327   // tile holes
 328   if(fabsf(vx) > MAX_WALK_XM) {
 329     bbox.set_width(34);
 330   } else {
 331     bbox.set_width(31.8);
 332   }
 333
 334   // on downward slopes, adjust vertical velocity to match slope angle
 335   if (on_ground()) {
 336     if (floor_normal.y != 0) {
 337       if ((floor_normal.x * vx) > 0) {
 338         // we overdo it a little, just to be on the safe side
 339         vy = vx * (floor_normal.x / floor_normal.y) * 2;
 340       }
 341     }
 342   }
 343
 344   physic.set_velocity(vx, vy);
 345   physic.set_acceleration(ax, ay);
 346 }
 347
 348 void
 349 Player::handle_vertical_input()
 350 {
 351   // set fall mode...
 352   if(on_ground()) {
 353     fall_mode = ON_GROUND;
 354     last_ground_y = get_pos().y;
 355   } else {
 356     if(get_pos().y > last_ground_y)
 357       fall_mode = FALLING;
 358     else if(fall_mode == ON_GROUND)
 359       fall_mode = JUMPING;
 360   }
 361
 362   if(on_ground()) { /* Make sure jumping is off. */
 363     jumping = false;
 364     if (backflipping) {
 365       backflipping = false;
 366       backflip_direction = 0;
 367     }
 368   }
 369
 370   // Press jump key
 371   if(controller->pressed(Controller::JUMP) && can_jump && on_ground()) {
 372     if (duck) {
 373       if (physic.get_velocity_x() != 0) // only jump a little bit when running ducked
 374         physic.set_velocity_y(300);
 375       else { //do a backflip
 376         backflipping = true;
 377         physic.set_velocity_y(580);
 378         backflip_timer.start(0.15);
 379       }
 380     }
 381     else if (fabs(physic.get_velocity_x()) > MAX_WALK_XM) // jump higher if we are running
 382       physic.set_velocity_y(580);
 383     else
 384       physic.set_velocity_y(520);
 385
 386     //bbox.move(Vector(0, -1));
 387     jumping = true;
 388     can_jump = false;
 389     if (is_big())
 390       sound_manager->play("sounds/bigjump.wav");
 391     else
 392       sound_manager->play("sounds/jump.wav");
 393   } else if(!controller->hold(Controller::JUMP)) { // Let go of jump key
 394     if (!backflipping && jumping && physic.get_velocity_y() > 0) {
 395       jumping = false;
 396       physic.set_velocity_y(0);
 397     }
 398   }
 399
 400   /* In case the player has pressed Down while in a certain range of air,
 401      enable butt jump action */
 402   if (controller->hold(Controller::DOWN) && !butt_jump && !duck)
 403     //if(tiles_on_air(TILES_FOR_BUTTJUMP) && jumping)
 404     butt_jump = true;
 405
 406   /* When Down is not held anymore, disable butt jump */
 407   if(butt_jump && !controller->hold(Controller::DOWN))
 408     butt_jump = false;
 409
 410 #if 0
 411   // Do butt jump
 412   if (butt_jump && on_ground() && is_big()) {
 413     // Add a smoke cloud
 414     if (duck)
 415       Sector::current()->add_smoke_cloud(Vector(get_pos().x - 32, get_pos().y));
 416     else
 417       Sector::current()->add_smoke_cloud(
 418         Vector(get_pos().x - 32, get_pos().y + 32));
 419
 420     butt_jump = false;
 421
 422     // Break bricks beneath Tux
 423     if(Sector::current()->trybreakbrick(
 424          Vector(base.x + 1, base.y + base.height), false)
 425        || Sector::current()->trybreakbrick(
 426          Vector(base.x + base.width - 1, base.y + base.height), false)) {
 427       physic.set_velocity_y(2);
 428       butt_jump = true;
 429     }
 430
 431     // Kill nearby badguys
 432     std::vector<GameObject*> gameobjects = Sector::current()->gameobjects;
 433     for (std::vector<GameObject*>::iterator i = gameobjects.begin();
 434          i != gameobjects.end();
 435          i++) {
 436       BadGuy* badguy = dynamic_cast<BadGuy*> (*i);
 437       if(badguy) {
 438         // don't kill when badguys are already dying or in a certain mode
 439         if(badguy->dying == DYING_NOT && badguy->mode != BadGuy::BOMB_TICKING &&
 440            badguy->mode != BadGuy::BOMB_EXPLODE) {
 441           if (fabsf(base.x - badguy->base.x) < 96 &&
 442               fabsf(base.y - badguy->base.y) < 64)
 443             badguy->kill_me(25);
 444         }
 445       }
 446     }
 447   }
 448 #endif
 449
 450   /** jumping is only allowed if we're about to touch ground soon and if the
 451    * button has been up in between the last jump
 452    */
 453   // FIXME
 454 #if 0
 455   if ( (issolid(get_pos().x + bbox.get_width() / 2,
 456           get_pos().y + bbox.get_height() + 64) ||
 457         issolid(get_pos().x + 1, get_pos().y + bbox.get_height() + 64) ||
 458         issolid(get_pos().x + bbox.get_width() - 1,
 459           get_pos().y + bbox.get_height() + 64))
 460        && jumping  == false
 461        && can_jump == false
 462        && input.jump && !input.old_jump)
 463     {
 464       can_jump = true;
 465     }
 466 #endif
 467 }
 468
 469 void
 470 Player::handle_input()
 471 {
 472   /* Handle horizontal movement: */
 473   if (!backflipping) handle_horizontal_input();
 474   else {
 475     if (backflip_direction == 0) {
 476       dir == LEFT ? backflip_direction = 1 : backflip_direction = -1;
 477     }
 478     else backflip_direction == 1 ? dir = LEFT : dir = RIGHT; //prevent player from changing direction when backflipping
 479     if (backflip_timer.check()) physic.set_velocity_x(100 * backflip_direction);
 480   }
 481
 482
 483   /* Jump/jumping? */
 484   if (on_ground() && !controller->hold(Controller::JUMP))
 485     can_jump = true;
 486   handle_vertical_input();
 487
 488   /* Shoot! */
 489   if (controller->pressed(Controller::ACTION) && player_status->bonus == FIRE_BONUS) {
 490     if(Sector::current()->add_bullet(
 491          get_pos() + ((dir == LEFT)? Vector(0, bbox.get_height()/2)
 492                       : Vector(32, bbox.get_height()/2)),
 493          physic.get_velocity_x(), dir))
 494       shooting_timer.start(SHOOTING_TIME);
 495   }
 496
 497   /* Duck! */
 498   if (controller->hold(Controller::DOWN) && is_big() && !duck
 499       && physic.get_velocity_y() == 0 && on_ground()) {
 500     duck = true;
 501     bbox.move(Vector(0, 32));
 502     bbox.set_height(31.8);
 503   } else if(!controller->hold(Controller::DOWN) && is_big() && duck) {
 504     // if we have some velocity left then check if there is space for
 505     // unducking
 506     bbox.move(Vector(0, -32));
 507     bbox.set_height(63.8);
 508     if(Sector::current()->is_free_space(bbox) || (
 509         physic.get_velocity_x() > -.01 && physic.get_velocity_x() < .01
 510         && physic.get_velocity_y() > -.01 && physic.get_velocity_y() < .01))
 511     {
 512       duck = false;
 513     } else {
 514       // undo the ducking changes
 515       bbox.move(Vector(0, 32));
 516       bbox.set_height(31.8);
 517     }
 518   }
 519 }
 520
 521 void
 522 Player::set_bonus(BonusType type, bool animate)
 523 {
 524   if(player_status->bonus >= type)
 525     return;
 526
 527   if(player_status->bonus == NO_BONUS) {
 528     bbox.set_height(63.8);
 529     bbox.move(Vector(0, -32));
 530     if(animate)
 531       growing_timer.start(GROWING_TIME);
 532   }
 533
 534   player_status->bonus = type;
 535 }
 536
 537 void
 538 Player::set_visible(bool visible)
 539 {
 540   this->visible = visible;
 541 }
 542
 543 bool
 544 Player::get_visible()
 545 {
 546   return visible;
 547 }
 548
 549 void
 550 Player::kick()
 551 {
 552   kick_timer.start(KICK_TIME);
 553 }
 554
 555 void
 556 Player::draw(DrawingContext& context)
 557 {
 558   if(!visible)
 559     return;
 560
 561   TuxBodyParts* tux_body;
 562
 563   if (player_status->bonus == GROWUP_BONUS)
 564     tux_body = big_tux;
 565   else if (player_status->bonus == FIRE_BONUS)
 566     tux_body = fire_tux;
 567   else if (player_status->bonus == ICE_BONUS)
 568     tux_body = ice_tux;
 569   else
 570     tux_body = small_tux;
 571
 572   int layer = LAYER_OBJECTS + 10;
 573
 574   /* Set Tux sprite action */
 575   if (duck && is_big())
 576     {
 577     if(dir == LEFT)
 578       tux_body->set_action("duck-left");
 579     else // dir == RIGHT
 580       tux_body->set_action("duck-right");
 581     }
 582   else if (skidding_timer.started() && !skidding_timer.check())
 583     {
 584     if(dir == LEFT)
 585       tux_body->set_action("skid-left");
 586     else // dir == RIGHT
 587       tux_body->set_action("skid-right");
 588     }
 589   else if (kick_timer.started() && !kick_timer.check())
 590     {
 591     if(dir == LEFT)
 592       tux_body->set_action("kick-left");
 593     else // dir == RIGHT
 594       tux_body->set_action("kick-right");
 595     }
 596   else if (butt_jump && is_big())
 597     {
 598     if(dir == LEFT)
 599       tux_body->set_action("buttjump-left");
 600     else // dir == RIGHT
 601       tux_body->set_action("buttjump-right");
 602     }
 603   else if (physic.get_velocity_y() != 0)
 604     {
 605     if(dir == LEFT)
 606       tux_body->set_action("jump-left");
 607     else // dir == RIGHT
 608       tux_body->set_action("jump-right");
 609     }
 610   else
 611     {
 612     if (fabsf(physic.get_velocity_x()) < 1.0f) // standing
 613       {
 614       if(dir == LEFT)
 615         tux_body->set_action("stand-left");
 616       else // dir == RIGHT
 617         tux_body->set_action("stand-right");
 618       }
 619     else // moving
 620       {
 621       if(dir == LEFT)
 622         tux_body->set_action("walk-left");
 623       else // dir == RIGHT
 624         tux_body->set_action("walk-right");
 625       }
 626     }
 627
 628   if(idle_timer.check())
 629     {
 630     if(is_big())
 631       {
 632       if(dir == LEFT)
 633         tux_body->head->set_action("idle-left", 1);
 634       else // dir == RIGHT
 635         tux_body->head->set_action("idle-right", 1);
 636       }
 637
 638     }
 639
 640   // Tux is holding something
 641   if ((grabbed_object != 0 && physic.get_velocity_y() == 0) ||
 642       (shooting_timer.get_timeleft() > 0 && !shooting_timer.check()))
 643     {
 644     if (duck)
 645       {
 646       if(dir == LEFT)
 647         tux_body->arms->set_action("duck+grab-left");
 648       else // dir == RIGHT
 649         tux_body->arms->set_action("duck+grab-right");
 650       }
 651     else
 652       {
 653       if(dir == LEFT)
 654         tux_body->arms->set_action("grab-left");
 655       else // dir == RIGHT
 656         tux_body->arms->set_action("grab-right");
 657       }
 658     }
 659
 660   /* Draw Tux */
 661   if(dying) {
 662     smalltux_gameover->draw(context, get_pos(), layer);
 663   } else if(growing_timer.get_timeleft() > 0) {
 664     if(!is_big())
 665       {
 666       if (dir == RIGHT)
 667         context.draw_surface(growingtux_right[GROWING_FRAMES-1 -
 668                  int((growing_timer.get_timegone() *
 669                  GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
 670       else
 671         context.draw_surface(growingtux_left[GROWING_FRAMES-1 -
 672                 int((growing_timer.get_timegone() *
 673                 GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
 674       }
 675     else
 676       {
 677       if (dir == RIGHT)
 678         context.draw_surface(growingtux_right[
 679             int((growing_timer.get_timegone() *
 680                 GROWING_FRAMES) / GROWING_TIME)], get_pos(), layer);
 681       else
 682         context.draw_surface(growingtux_left[
 683             int((growing_timer.get_timegone() *
 684                              GROWING_FRAMES) / GROWING_TIME)],
 685             get_pos(), layer);
 686       }
 687     }
 688   else if (safe_timer.started() && size_t(game_time*40)%2)
 689     ;  // don't draw Tux
 690   else
 691     tux_body->draw(context, get_pos(), layer);
 692
 693   // Draw blinking star overlay
 694   if (invincible_timer.started() &&
 695      (invincible_timer.get_timeleft() > TUX_INVINCIBLE_TIME_WARNING
 696       || size_t(game_time*20)%2)
 697      && !dying)
 698   {
 699     if (!is_big() || duck)
 700       smalltux_star->draw(context, get_pos(), layer + 5);
 701     else
 702       bigtux_star->draw(context, get_pos(), layer + 5);
 703   }
 704 }
 705
 706 void
 707 Player::collision_tile(uint32_t tile_attributes)
 708 {
 709   if(tile_attributes & Tile::HURTS)
 710     kill(SHRINK);
 711 }
 712
 713 HitResponse
 714 Player::collision(GameObject& other, const CollisionHit& hit)
 715 {
 716   Bullet* bullet = dynamic_cast<Bullet*> (&other);
 717   if(bullet) {
 718     return FORCE_MOVE;
 719   }
 720
 721   if(other.get_flags() & FLAG_PORTABLE) {
 722     Portable* portable = dynamic_cast<Portable*> (&other);
 723     if(portable && grabbed_object == 0 && controller->hold(Controller::ACTION)
 724         && fabsf(hit.normal.x) > .9) {
 725       grabbed_object = portable;
 726       return CONTINUE;
 727     }
 728   }
 729
 730   if(other.get_flags() & FLAG_SOLID) {
 731     if(hit.normal.y < 0) { // landed on floor?
 732       if(physic.get_velocity_y() < 0)
 733         physic.set_velocity_y(0);
 734       on_ground_flag = true;
 735
 736       // remember normal of this tile
 737       if (hit.normal.y > -0.9) {
 738         floor_normal.x = hit.normal.x;
 739         floor_normal.y = hit.normal.y;
 740       } else {
 741         // slowly adjust to unisolid tiles.
 742         // Necessary because our bounding box sometimes reaches through slopes and thus hits unisolid tiles
 743         floor_normal.x = (floor_normal.x * 0.9) + (hit.normal.x * 0.1);
 744         floor_normal.y = (floor_normal.y * 0.9) + (hit.normal.y * 0.1);
 745       }
 746
 747       // disable gravity
 748       physic.enable_gravity(false);
 749     } else if(hit.normal.y > 0) { // bumped against the roof
 750       physic.set_velocity_y(.1);
 751     }
 752
 753     if(fabsf(hit.normal.x) > .9) { // hit on the side?
 754       physic.set_velocity_x(0);
 755     }
 756
 757     return CONTINUE;
 758   }
 759
 760 #ifdef DEBUG
 761   assert(dynamic_cast<MovingObject*> (&other) != NULL);
 762 #endif
 763   MovingObject* moving_object = static_cast<MovingObject*> (&other);
 764   if(moving_object->get_group() == COLGROUP_TOUCHABLE) {
 765     TriggerBase* trigger = dynamic_cast<TriggerBase*> (&other);
 766     if(trigger) {
 767       if(controller->pressed(Controller::UP))
 768         trigger->event(*this, TriggerBase::EVENT_ACTIVATE);
 769     }
 770
 771     return FORCE_MOVE;
 772   }
 773
 774   BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
 775   if(badguy != NULL) {
 776     if(safe_timer.started())
 777       return FORCE_MOVE;
 778
 779     return CONTINUE;
 780   }
 781
 782   return FORCE_MOVE;
 783 }
 784
 785 void
 786 Player::make_invincible()
 787 {
 788   sound_manager->play("sounds/invincible.wav");
 789   invincible_timer.start(TUX_INVINCIBLE_TIME);
 790   Sector::current()->play_music(HERRING_MUSIC);
 791 }
 792
 793 /* Kill Player! */
 794 void
 795 Player::kill(HurtMode mode)
 796 {
 797   if(dying || deactivated)
 798     return;
 799
 800   if(mode != KILL &&
 801           (safe_timer.get_timeleft() > 0 || invincible_timer.get_timeleft() > 0))
 802     return;
 803
 804   sound_manager->play("sounds/hurt.wav");
 805
 806   physic.set_velocity_x(0);
 807
 808   if (mode == SHRINK && is_big())
 809     {
 810       if (player_status->bonus == FIRE_BONUS
 811           || player_status->bonus == ICE_BONUS)
 812         {
 813           safe_timer.start(TUX_SAFE_TIME);
 814           player_status->bonus = GROWUP_BONUS;
 815         }
 816       else
 817         {
 818           growing_timer.start(GROWING_TIME);
 819           safe_timer.start(TUX_SAFE_TIME + GROWING_TIME);
 820           bbox.set_height(31.8);
 821           duck = false;
 822           player_status->bonus = NO_BONUS;
 823         }
 824     }
 825   else
 826     {
 827       physic.enable_gravity(true);
 828       physic.set_acceleration(0, 0);
 829       physic.set_velocity(0, 700);
 830       player_status->lives -= 1;
 831       player_status->bonus = NO_BONUS;
 832       dying = true;
 833       dying_timer.start(3.0);
 834       set_group(COLGROUP_DISABLED);
 835
 836       DisplayEffect* effect = new DisplayEffect();
 837       effect->fade_out(3.0);
 838       Sector::current()->add_object(effect);
 839       sound_manager->stop_music(3.0);
 840     }
 841 }
 842
 843 void
 844 Player::move(const Vector& vector)
 845 {
 846   bbox.set_pos(vector);
 847   if(is_big())
 848     bbox.set_size(31.8, 63.8);
 849   else
 850     bbox.set_size(31.8, 31.8);
 851   duck = false;
 852   last_ground_y = vector.y;
 853
 854   physic.reset();
 855 }
 856
 857 void
 858 Player::check_bounds(Camera* camera)
 859 {
 860   /* Keep tux in bounds: */
 861   if (get_pos().x < 0)
 862     { // Lock Tux to the size of the level, so that he doesn't fall of
 863       // on the left side
 864       bbox.set_pos(Vector(0, get_pos().y));
 865     }
 866
 867   /* Keep in-bounds, vertically: */
 868   if (get_pos().y > Sector::current()->solids->get_height() * 32)
 869     {
 870       kill(KILL);
 871       return;
 872     }
 873
 874   bool adjust = false;
 875   // can happen if back scrolling is disabled
 876   if(get_pos().x < camera->get_translation().x) {
 877     bbox.set_pos(Vector(camera->get_translation().x, get_pos().y));
 878     adjust = true;
 879   }
 880   if(get_pos().x >= camera->get_translation().x + SCREEN_WIDTH - bbox.get_width())
 881   {
 882     bbox.set_pos(Vector(
 883           camera->get_translation().x + SCREEN_WIDTH - bbox.get_width(),
 884           get_pos().y));
 885     adjust = true;
 886   }
 887
 888   if(adjust) {
 889     // FIXME
 890 #if 0
 891     // squished now?
 892     if(collision_object_map(bbox)) {
 893       kill(KILL);
 894       return;
 895     }
 896 #endif
 897   }
 898 }
 899
 900 void
 901 Player::bounce(BadGuy& )
 902 {
 903   if(controller->hold(Controller::JUMP))
 904     physic.set_velocity_y(520);
 905   else
 906     physic.set_velocity_y(300);
 907 }
 908
 909 //Scripting Functions Below
 910
 911 void
 912 Player::deactivate()
 913 {
 914   deactivated = true;
 915   physic.set_velocity_x(0);
 916   physic.set_velocity_y(0);
 917 }
 918
 919 void
 920 Player::activate()
 921 {
 922   deactivated = false;
 923 }
 924
 925 void Player::walk(float speed)
 926 {
 927   physic.set_velocity_x(speed);
 928 }