src/badguy/snail.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux - Badguy "Snail"
   4 //  Copyright (C) 2006 Christoph Sommer <christoph.sommer@2006.expires.deltadevelopment.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 "snail.hpp"
  23 #include "object/block.hpp"
  24
  25 namespace {
  26   const float KICKSPEED = 500;
  27   const int MAXSQUISHES = 10;
  28   const float KICKSPEED_Y = -500; /**< y-velocity gained when kicked */
  29 }
  30
  31 Snail::Snail(const lisp::Lisp& reader)
  32   : WalkingBadguy(reader, "images/creatures/snail/snail.sprite", "left", "right"), state(STATE_NORMAL), squishcount(0)
  33 {
  34   walk_speed = 80;
  35   max_drop_height = 600;
  36   sound_manager->preload("sounds/iceblock_bump.wav");
  37   sound_manager->preload("sounds/stomp.wav");
  38   sound_manager->preload("sounds/kick.wav");
  39 }
  40
  41 Snail::Snail(const Vector& pos, Direction d)
  42   : WalkingBadguy(pos, d, "images/creatures/snail/snail.sprite", "left", "right"), state(STATE_NORMAL), squishcount(0)
  43 {
  44   walk_speed = 80;
  45   max_drop_height = 600;
  46   sound_manager->preload("sounds/iceblock_bump.wav");
  47   sound_manager->preload("sounds/stomp.wav");
  48   sound_manager->preload("sounds/kick.wav");
  49 }
  50
  51 void
  52 Snail::write(lisp::Writer& writer)
  53 {
  54   writer.start_list("snail");
  55   WalkingBadguy::write(writer);
  56   writer.end_list("snail");
  57 }
  58
  59 void
  60 Snail::activate()
  61 {
  62   WalkingBadguy::activate();
  63   be_normal();
  64 }
  65
  66 void
  67 Snail::be_normal()
  68 {
  69   if (state == STATE_NORMAL) return;
  70
  71   state = STATE_NORMAL;
  72   WalkingBadguy::activate();
  73 }
  74
  75 void
  76 Snail::be_flat()
  77 {
  78   state = STATE_FLAT;
  79   sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
  80   sprite->set_fps(64);
  81
  82   physic.set_velocity_x(0);
  83   physic.set_velocity_y(0);
  84
  85   flat_timer.start(4);
  86 }
  87
  88 void
  89 Snail::be_kicked()
  90 {
  91   state = STATE_KICKED_DELAY;
  92   sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
  93   sprite->set_fps(64);
  94
  95   physic.set_velocity_x(0);
  96   physic.set_velocity_y(0);
  97
  98   // start a timer to delay addition of upward movement until we are (hopefully) out from under the player
  99   kicked_delay_timer.start(0.05);
 100 }
 101
 102 bool
 103 Snail::can_break(){
 104     return state == STATE_KICKED;
 105 }
 106
 107 void
 108 Snail::active_update(float elapsed_time)
 109 {
 110   switch (state) {
 111
 112     case STATE_NORMAL:
 113       WalkingBadguy::active_update(elapsed_time);
 114       break;
 115
 116     case STATE_FLAT:
 117       if (flat_timer.started()) {
 118         sprite->set_fps(64 - 15 * flat_timer.get_timegone());
 119       }
 120       if (flat_timer.check()) {
 121         be_normal();
 122       }
 123       BadGuy::active_update(elapsed_time);
 124       break;
 125
 126     case STATE_KICKED_DELAY:
 127       if (kicked_delay_timer.check()) {
 128         physic.set_velocity_x(dir == LEFT ? -KICKSPEED : KICKSPEED);
 129         physic.set_velocity_y(KICKSPEED_Y);
 130         state = STATE_KICKED;
 131       }
 132       BadGuy::active_update(elapsed_time);
 133       break;
 134
 135     case STATE_KICKED:
 136       physic.set_velocity_x(physic.get_velocity_x() * pow(0.99, elapsed_time/0.02));
 137       if (fabsf(physic.get_velocity_x()) < walk_speed) be_normal();
 138       BadGuy::active_update(elapsed_time);
 139       break;
 140
 141   }
 142 }
 143
 144 void
 145 Snail::collision_solid(const CollisionHit& hit)
 146 {
 147   update_on_ground_flag(hit);
 148
 149   switch (state) {
 150     case STATE_NORMAL:
 151       WalkingBadguy::collision_solid(hit);
 152       break;
 153     case STATE_FLAT:
 154       if(hit.top || hit.bottom) {
 155         physic.set_velocity_y(0);
 156       }
 157       if(hit.left || hit.right) {
 158       }
 159       break;
 160     case STATE_KICKED_DELAY:
 161       if(hit.top || hit.bottom) {
 162         physic.set_velocity_y(0);
 163       }
 164       if(hit.left || hit.right) {
 165         physic.set_velocity_x(0);
 166       }
 167       break;
 168     case STATE_KICKED:
 169       if(hit.top || hit.bottom) {
 170         physic.set_velocity_y(0);
 171       }
 172       if(hit.left || hit.right) {
 173         sound_manager->play("sounds/iceblock_bump.wav", get_pos());
 174
 175         if( ( dir == LEFT && hit.left ) || ( dir == RIGHT && hit.right) ){
 176           dir = (dir == LEFT) ? RIGHT : LEFT;
 177           sprite->set_action(dir == LEFT ? "flat-left" : "flat-right");
 178
 179           physic.set_velocity_x(-physic.get_velocity_x()*0.75);
 180           if (fabsf(physic.get_velocity_x()) < walk_speed) be_normal();
 181         }
 182
 183       }
 184       break;
 185   }
 186
 187 }
 188
 189 HitResponse
 190 Snail::collision_badguy(BadGuy& badguy, const CollisionHit& hit)
 191 {
 192   switch(state) {
 193     case STATE_NORMAL:
 194       return WalkingBadguy::collision_badguy(badguy, hit);
 195     case STATE_FLAT:
 196     case STATE_KICKED_DELAY:
 197       return FORCE_MOVE;
 198     case STATE_KICKED:
 199       badguy.kill_fall();
 200       return FORCE_MOVE;
 201     default:
 202       assert(false);
 203   }
 204
 205   return ABORT_MOVE;
 206 }
 207
 208 bool
 209 Snail::collision_squished(GameObject& object)
 210 {
 211   switch(state) {
 212
 213     case STATE_KICKED:
 214     case STATE_NORMAL:
 215       squishcount++;
 216       if(squishcount >= MAXSQUISHES) {
 217         kill_fall();
 218         return true;
 219       }
 220
 221       sound_manager->play("sounds/stomp.wav", get_pos());
 222       be_flat();
 223       break;
 224
 225     case STATE_FLAT:
 226       sound_manager->play("sounds/kick.wav", get_pos());
 227       {
 228         MovingObject* movingobject = dynamic_cast<MovingObject*>(&object);
 229         if (movingobject && (movingobject->get_pos().x < get_pos().x)) {
 230           dir = RIGHT;
 231         } else {
 232           dir = LEFT;
 233         }
 234       }
 235       be_kicked();
 236       break;
 237
 238     case STATE_KICKED_DELAY:
 239       break;
 240
 241   }
 242
 243   Player* player = dynamic_cast<Player*>(&object);
 244   if (player) player->bounce(*this);
 245   return true;
 246 }
 247
 248 IMPLEMENT_FACTORY(Snail, "snail")