src/badguy/mriceblock.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2005 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
  19 //  02111-1307, USA.
  20
  21 #include <config.h>
  22
  23 #include "mriceblock.hpp"
  24 #include "object/block.hpp"
  25
  26 static const float WALKSPEED = 80;
  27 static const float KICKSPEED = 500;
  28 static const int MAXSQUISHES = 10;
  29
  30 MrIceBlock::MrIceBlock(const lisp::Lisp& reader)
  31   : ice_state(ICESTATE_NORMAL), squishcount(0)
  32 {
  33   reader.get("x", start_position.x);
  34   reader.get("y", start_position.y);
  35   stay_on_platform = false;
  36   reader.get("stay-on-platform", stay_on_platform);
  37   bbox.set_size(31.8, 31.8);
  38   sprite = sprite_manager->create("images/creatures/mr_iceblock/mr_iceblock.sprite");
  39   set_direction = false;
  40 }
  41
  42 MrIceBlock::MrIceBlock(float pos_x, float pos_y, Direction d, bool stay_on_plat = false )
  43   : ice_state(ICESTATE_NORMAL), squishcount(0)
  44 {
  45   start_position.x = pos_x;
  46   start_position.y = pos_y;
  47   stay_on_platform = stay_on_plat;
  48   bbox.set_size(31.8, 31.8);
  49   sprite = sprite_manager->create("images/creatures/mr_iceblock/mr_iceblock.sprite");
  50   set_direction = true;
  51   initial_direction = d;
  52 }
  53
  54 void
  55 MrIceBlock::write(lisp::Writer& writer)
  56 {
  57   writer.start_list("mriceblock");
  58
  59   writer.write_float("x", start_position.x);
  60   writer.write_float("y", start_position.y);
  61   writer.write_bool("stay-on-platform", stay_on_platform);
  62
  63   writer.end_list("mriceblock");
  64 }
  65
  66 void
  67 MrIceBlock::activate()
  68 {
  69   if (set_direction) {
  70     dir = initial_direction;
  71   }
  72
  73   physic.set_velocity_x(dir == LEFT ? -WALKSPEED : WALKSPEED);
  74   sprite->set_action(dir == LEFT ? "left" : "right");
  75 }
  76
  77 void
  78 MrIceBlock::active_update(float elapsed_time)
  79 {
  80   if(ice_state == ICESTATE_GRABBED)
  81     return;
  82
  83   if(ice_state == ICESTATE_FLAT && flat_timer.check()) {
  84     set_state(ICESTATE_NORMAL);
  85   }
  86
  87   if (ice_state == ICESTATE_NORMAL &&
  88       stay_on_platform &&
  89       may_fall_off_platform())
  90   {
  91     dir = (dir == LEFT ? RIGHT : LEFT);
  92     sprite->set_action(dir == LEFT ? "left" : "right");
  93     physic.set_velocity_x(-physic.get_velocity_x());
  94   }
  95
  96   BadGuy::active_update(elapsed_time);
  97 }
  98
  99 HitResponse
 100 MrIceBlock::collision_solid(GameObject& object, const CollisionHit& hit)
 101 {
 102   if(fabsf(hit.normal.y) > .5) { // floor or roof
 103     physic.set_velocity_y(0);
 104     return CONTINUE;
 105   }
 106   // hit left or right
 107   switch(ice_state) {
 108     case ICESTATE_NORMAL:
 109       dir = dir == LEFT ? RIGHT : LEFT;
 110       sprite->set_action(dir == LEFT ? "left" : "right");
 111       physic.set_velocity_x(-physic.get_velocity_x());
 112       break;
 113     case ICESTATE_KICKED: {
 114       BonusBlock* bonusblock = dynamic_cast<BonusBlock*> (&object);
 115       if(bonusblock) {
 116         bonusblock->try_open();
 117       }
 118       Brick* brick = dynamic_cast<Brick*> (&object);
 119       if(brick) {
 120         brick->try_break();
 121       }
 122
 123       dir = dir == LEFT ? RIGHT : LEFT;
 124       sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 125       physic.set_velocity_x(-physic.get_velocity_x());
 126       sound_manager->play("sounds/iceblock_bump.wav", get_pos());
 127       break;
 128     }
 129     case ICESTATE_FLAT:
 130       physic.set_velocity_x(0);
 131       break;
 132     case ICESTATE_GRABBED:
 133       return FORCE_MOVE;
 134   }
 135
 136   return CONTINUE;
 137 }
 138
 139 HitResponse
 140 MrIceBlock::collision(GameObject& object, const CollisionHit& hit)
 141 {
 142   if(ice_state == ICESTATE_GRABBED)
 143     return FORCE_MOVE;
 144
 145   return BadGuy::collision(object, hit);
 146 }
 147
 148 HitResponse
 149 MrIceBlock::collision_player(Player& player, const CollisionHit& hit)
 150 {
 151   if(ice_state == ICESTATE_GRABBED)
 152     return FORCE_MOVE;
 153
 154   // handle kicks from left or right side
 155   if(ice_state == ICESTATE_FLAT && get_state() == STATE_ACTIVE) {
 156     // hit from left side
 157     if(hit.normal.x > 0.7) {
 158       dir = RIGHT;
 159       player.kick();
 160       set_state(ICESTATE_KICKED);
 161       return FORCE_MOVE;
 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")