src/badguy/mriceblock.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
  20 #include <config.h>
  21
  22 #include "mriceblock.hpp"
  23 #include "object/block.hpp"
  24
  25 namespace {
  26   const float WALKSPEED = 80;
  27   const float KICKSPEED = 500;
  28   const int MAXSQUISHES = 10;
  29 }
  30
  31 MrIceBlock::MrIceBlock(const lisp::Lisp& reader)
  32   : ice_state(ICESTATE_NORMAL), squishcount(0)
  33 {
  34   reader.get("x", start_position.x);
  35   reader.get("y", start_position.y);
  36   bbox.set_size(31.8, 31.8);
  37   sprite = sprite_manager->create("images/creatures/mr_iceblock/mr_iceblock.sprite");
  38   set_direction = false;
  39 }
  40
  41 MrIceBlock::MrIceBlock(float pos_x, float pos_y, Direction d)
  42   : ice_state(ICESTATE_NORMAL), squishcount(0)
  43 {
  44   start_position.x = pos_x;
  45   start_position.y = pos_y;
  46   bbox.set_size(31.8, 31.8);
  47   sprite = sprite_manager->create("images/creatures/mr_iceblock/mr_iceblock.sprite");
  48   set_direction = true;
  49   initial_direction = d;
  50 }
  51
  52 void
  53 MrIceBlock::write(lisp::Writer& writer)
  54 {
  55   writer.start_list("mriceblock");
  56
  57   writer.write_float("x", start_position.x);
  58   writer.write_float("y", start_position.y);
  59
  60   writer.end_list("mriceblock");
  61 }
  62
  63 void
  64 MrIceBlock::activate()
  65 {
  66   if (set_direction) {
  67     dir = initial_direction;
  68   }
  69
  70   physic.set_velocity_x(dir == LEFT ? -WALKSPEED : WALKSPEED);
  71   sprite->set_action(dir == LEFT ? "left" : "right");
  72 }
  73
  74 void
  75 MrIceBlock::active_update(float elapsed_time)
  76 {
  77   if(ice_state == ICESTATE_GRABBED)
  78     return;
  79
  80   if(ice_state == ICESTATE_FLAT && flat_timer.check()) {
  81     set_state(ICESTATE_NORMAL);
  82   }
  83
  84   if (ice_state == ICESTATE_NORMAL && might_fall(601))
  85   {
  86     dir = (dir == LEFT ? RIGHT : LEFT);
  87     sprite->set_action(dir == LEFT ? "left" : "right");
  88     physic.set_velocity_x(-physic.get_velocity_x());
  89   }
  90
  91   BadGuy::active_update(elapsed_time);
  92 }
  93
  94 HitResponse
  95 MrIceBlock::collision_solid(GameObject& object, const CollisionHit& hit)
  96 {
  97   if(fabsf(hit.normal.y) > .5) { // floor or roof
  98     physic.set_velocity_y(0);
  99     return CONTINUE;
 100   }
 101   // hit left or right
 102   switch(ice_state) {
 103     case ICESTATE_NORMAL:
 104       dir = dir == LEFT ? RIGHT : LEFT;
 105       sprite->set_action(dir == LEFT ? "left" : "right");
 106       physic.set_velocity_x(-physic.get_velocity_x());
 107       break;
 108     case ICESTATE_KICKED: {
 109       BonusBlock* bonusblock = dynamic_cast<BonusBlock*> (&object);
 110       if(bonusblock) {
 111         bonusblock->try_open();
 112       }
 113       Brick* brick = dynamic_cast<Brick*> (&object);
 114       if(brick) {
 115         brick->try_break();
 116       }
 117
 118       dir = dir == LEFT ? RIGHT : LEFT;
 119       sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 120       physic.set_velocity_x(-physic.get_velocity_x());
 121       sound_manager->play("sounds/iceblock_bump.wav", get_pos());
 122       break;
 123     }
 124     case ICESTATE_FLAT:
 125       physic.set_velocity_x(0);
 126       break;
 127     case ICESTATE_GRABBED:
 128       return FORCE_MOVE;
 129   }
 130
 131   return CONTINUE;
 132 }
 133
 134 HitResponse
 135 MrIceBlock::collision(GameObject& object, const CollisionHit& hit)
 136 {
 137   if(ice_state == ICESTATE_GRABBED)
 138     return FORCE_MOVE;
 139
 140   return BadGuy::collision(object, hit);
 141 }
 142
 143 HitResponse
 144 MrIceBlock::collision_player(Player& player, const CollisionHit& hit)
 145 {
 146   if(ice_state == ICESTATE_GRABBED)
 147     return FORCE_MOVE;
 148
 149   // handle kicks from left or right side
 150   if(ice_state == ICESTATE_FLAT && get_state() == STATE_ACTIVE) {
 151     // Don't kick if the player is going to pick us up
 152     if (player.get_controller()->hold(Controller::ACTION))
 153         return FORCE_MOVE;
 154
 155     // hit from left side
 156     if(hit.normal.x > 0.7) {
 157       dir = RIGHT;
 158       player.kick();
 159       set_state(ICESTATE_KICKED);
 160       return FORCE_MOVE;
 161     }
 162     else if(hit.normal.x < -0.7) {
 163       dir = LEFT;
 164       player.kick();
 165       set_state(ICESTATE_KICKED);
 166       return FORCE_MOVE;
 167     }
 168   }
 169
 170   return BadGuy::collision_player(player, hit);
 171 }
 172
 173 HitResponse
 174 MrIceBlock::collision_badguy(BadGuy& badguy, const CollisionHit& hit)
 175 {
 176   switch(ice_state) {
 177     case ICESTATE_NORMAL:
 178       if(fabsf(hit.normal.x) > .8) {
 179         dir = dir == LEFT ? RIGHT : LEFT;
 180         sprite->set_action(dir == LEFT ? "left" : "right");
 181         physic.set_velocity_x(-physic.get_velocity_x());
 182       }
 183       return CONTINUE;
 184     case ICESTATE_FLAT:
 185       return FORCE_MOVE;
 186     case ICESTATE_KICKED:
 187       badguy.kill_fall();
 188       return FORCE_MOVE;
 189     default:
 190       assert(false);
 191   }
 192
 193   return ABORT_MOVE;
 194 }
 195
 196 bool
 197 MrIceBlock::collision_squished(Player& player)
 198 {
 199   switch(ice_state) {
 200     case ICESTATE_KICKED:
 201     case ICESTATE_NORMAL:
 202       squishcount++;
 203       if(squishcount >= MAXSQUISHES) {
 204         kill_fall();
 205         return true;
 206       }
 207
 208       set_state(ICESTATE_FLAT);
 209       break;
 210     case ICESTATE_FLAT:
 211       if(player.get_pos().x < get_pos().x) {
 212         dir = RIGHT;
 213       } else {
 214         dir = LEFT;
 215       }
 216       set_state(ICESTATE_KICKED);
 217       break;
 218     case ICESTATE_GRABBED:
 219       assert(false);
 220       break;
 221   }
 222
 223   player.bounce(*this);
 224   return true;
 225 }
 226
 227 void
 228 MrIceBlock::set_state(IceState state)
 229 {
 230   if(ice_state == state)
 231     return;
 232
 233   if(state == ICESTATE_FLAT)
 234     flags |= FLAG_PORTABLE;
 235   else
 236     flags &= ~FLAG_PORTABLE;
 237
 238   if(ice_state == ICESTATE_KICKED) {
 239     bbox.set_size(31.8, 31.8);
 240   }
 241
 242   switch(state) {
 243     case ICESTATE_NORMAL:
 244       physic.set_velocity_x(dir == LEFT ? -WALKSPEED : WALKSPEED);
 245       sprite->set_action(dir == LEFT ? "left" : "right");
 246       break;
 247     case ICESTATE_FLAT:
 248       sound_manager->play("sounds/stomp.wav", get_pos());
 249       physic.set_velocity_x(0);
 250       physic.set_velocity_y(0);
 251
 252       sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 253       flat_timer.start(4);
 254       break;
 255     case ICESTATE_KICKED:
 256       sound_manager->play("sounds/kick.wav", get_pos());
 257
 258       physic.set_velocity_x(dir == LEFT ? -KICKSPEED : KICKSPEED);
 259       sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 260       // we should slide above 1 block holes now...
 261       bbox.set_size(34, 31.8);
 262       break;
 263     case ICESTATE_GRABBED:
 264       flat_timer.stop();
 265       break;
 266     default:
 267       assert(false);
 268   }
 269   ice_state = state;
 270 }
 271
 272 void
 273 MrIceBlock::grab(MovingObject&, const Vector& pos, Direction dir)
 274 {
 275   movement = pos - get_pos();
 276   this->dir = dir;
 277   sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 278   set_state(ICESTATE_GRABBED);
 279   set_group(COLGROUP_DISABLED);
 280 }
 281
 282 void
 283 MrIceBlock::ungrab(MovingObject& , Direction dir)
 284 {
 285   this->dir = dir;
 286   set_state(ICESTATE_KICKED);
 287   set_group(COLGROUP_MOVING);
 288 }
 289
 290 IMPLEMENT_FACTORY(MrIceBlock, "mriceblock")