src/badguy/badguy.cpp

   1 #include <config.h>
   2
   3 #include "badguy.h"
   4 #include "object/camera.h"
   5
   6 static const float SQUISH_TIME = 2;
   7 static const float X_OFFSCREEN_DISTANCE = 1600;
   8 static const float Y_OFFSCREEN_DISTANCE = 1200;
   9
  10 BadGuy::BadGuy()
  11   : sprite(0), dir(LEFT), state(STATE_INIT)
  12 {
  13   hitpoints = 1;
  14 }
  15
  16 BadGuy::~BadGuy()
  17 {
  18   delete sprite;
  19 }
  20
  21 void
  22 BadGuy::draw(DrawingContext& context)
  23 {
  24   if(!sprite)
  25     return;
  26   if(state == STATE_INIT || state == STATE_INACTIVE)
  27     return;
  28   if(state == STATE_FALLING) {
  29     sprite->draw(context, get_pos(), LAYER_OBJECTS, VERTICAL_FLIP);
  30   } else {
  31     sprite->draw(context, get_pos(), LAYER_OBJECTS);
  32   }
  33 }
  34
  35 void
  36 BadGuy::action(float elapsed_time)
  37 {
  38   if(!Sector::current()->inside(bbox)) {
  39     remove_me();
  40     return;
  41   }
  42   if(is_offscreen()) {
  43     set_state(STATE_INACTIVE);
  44   }
  45
  46   switch(state) {
  47     case STATE_ACTIVE:
  48       active_action(elapsed_time);
  49       break;
  50     case STATE_INIT:
  51     case STATE_INACTIVE:
  52       inactive_action(elapsed_time);
  53       try_activate();
  54       break;
  55     case STATE_SQUISHED:
  56       if(state_timer.check()) {
  57         remove_me();
  58         break;
  59       }
  60       movement = physic.get_movement(elapsed_time);
  61       break;
  62     case STATE_FALLING:
  63       movement = physic.get_movement(elapsed_time);
  64       break;
  65   }
  66 }
  67
  68 void
  69 BadGuy::activate()
  70 {
  71 }
  72
  73 void
  74 BadGuy::deactivate()
  75 {
  76 }
  77
  78 void
  79 BadGuy::active_action(float elapsed_time)
  80 {
  81   movement = physic.get_movement(elapsed_time);
  82 }
  83
  84 void
  85 BadGuy::inactive_action(float )
  86 {
  87 }
  88
  89 HitResponse
  90 BadGuy::collision(GameObject& other, const CollisionHit& hit)
  91 {
  92   switch(state) {
  93     case STATE_INIT:
  94     case STATE_INACTIVE:
  95       return ABORT_MOVE;
  96     case STATE_ACTIVE: {
  97       if(other.get_flags() & FLAG_SOLID)
  98         return collision_solid(other, hit);
  99
 100       BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
 101       if(badguy && badguy->state == STATE_ACTIVE)
 102         return collision_badguy(*badguy, hit);
 103
 104       Player* player = dynamic_cast<Player*> (&other);
 105       if(player)
 106         return collision_player(*player, hit);
 107
 108       return FORCE_MOVE;
 109     }
 110     case STATE_SQUISHED:
 111       if(other.get_flags() & FLAG_SOLID)
 112         return CONTINUE;
 113       return FORCE_MOVE;
 114     case STATE_FALLING:
 115       return FORCE_MOVE;
 116   }
 117
 118   return ABORT_MOVE;
 119 }
 120
 121 HitResponse
 122 BadGuy::collision_solid(GameObject& , const CollisionHit& )
 123 {
 124   return FORCE_MOVE;
 125 }
 126
 127 HitResponse
 128 BadGuy::collision_player(Player& player, const CollisionHit& hit)
 129 {
 130   if(player.is_invincible()) {
 131     kill_fall();
 132     return ABORT_MOVE;
 133   }
 134   if(hit.normal.y > .9) {
 135     //TODO: fix inaccuracy (tux sometimes dies even if badguy was hit)
 136     //      give badguys some invincible time (prevent them from being hit multiple times)
 137     //      use hitpoints also when hit by fireball or invincible tux
 138     hitpoints--;
 139     if(collision_squished(player))
 140       return ABORT_MOVE;
 141     else if (hitpoints <= 0) {
 142       player.kill(Player::SHRINK);
 143       return FORCE_MOVE;
 144     }
 145   }
 146   player.kill(Player::SHRINK);
 147   return FORCE_MOVE;
 148 }
 149
 150 HitResponse
 151 BadGuy::collision_badguy(BadGuy& , const CollisionHit& )
 152 {
 153   return FORCE_MOVE;
 154 }
 155
 156 bool
 157 BadGuy::collision_squished(Player& )
 158 {
 159   return false;
 160 }
 161
 162 void
 163 BadGuy::kill_squished(Player& player)
 164 {
 165   SoundManager::get()->play_sound(IDToSound(SND_SQUISH), get_pos(),
 166       player.get_pos());
 167   physic.enable_gravity(true);
 168   physic.set_velocity_x(0);
 169   physic.set_velocity_y(0);
 170   set_state(STATE_SQUISHED);
 171   player.bounce(*this);
 172 }
 173
 174 void
 175 BadGuy::kill_fall()
 176 {
 177   SoundManager::get()->play_sound(IDToSound(SND_FALL), this,
 178       Sector::current()->player->get_pos());
 179   physic.set_velocity_y(0);
 180   physic.enable_gravity(true);
 181   set_state(STATE_FALLING);
 182 }
 183
 184 void
 185 BadGuy::set_state(State state)
 186 {
 187   if(this->state == state)
 188     return;
 189
 190   State laststate = this->state;
 191   this->state = state;
 192   switch(state) {
 193     case STATE_SQUISHED:
 194       state_timer.start(SQUISH_TIME);
 195       break;
 196     case STATE_ACTIVE:
 197       flags &= ~FLAG_NO_COLLDET;
 198       bbox.set_pos(start_position);
 199       break;
 200     case STATE_INACTIVE:
 201       // was the badguy dead anyway?
 202       if(laststate == STATE_SQUISHED || laststate == STATE_FALLING) {
 203         remove_me();
 204       }
 205       flags |= FLAG_NO_COLLDET;
 206       break;
 207     case STATE_FALLING:
 208       flags |= FLAG_NO_COLLDET;
 209       break;
 210     default:
 211       break;
 212   }
 213 }
 214
 215 bool
 216 BadGuy::is_offscreen()
 217 {
 218   float scroll_x = Sector::current()->camera->get_translation().x;
 219   float scroll_y = Sector::current()->camera->get_translation().y;
 220
 221   if(bbox.p2.x < scroll_x - X_OFFSCREEN_DISTANCE
 222       || bbox.p1.x > scroll_x + X_OFFSCREEN_DISTANCE
 223       || bbox.p2.y < scroll_y - Y_OFFSCREEN_DISTANCE
 224       || bbox.p1.y > scroll_y + Y_OFFSCREEN_DISTANCE)
 225     return true;
 226
 227   return false;
 228 }
 229
 230 void
 231 BadGuy::try_activate()
 232 {
 233   float scroll_x = Sector::current()->camera->get_translation().x;
 234   float scroll_y = Sector::current()->camera->get_translation().y;
 235
 236   /* Activate badguys if they're just around the screen to avoid
 237    * the effect of having badguys suddenly popping up from nowhere.
 238    */
 239   if (start_position.x > scroll_x - X_OFFSCREEN_DISTANCE &&
 240       start_position.x < scroll_x - bbox.get_width() &&
 241       start_position.y > scroll_y - Y_OFFSCREEN_DISTANCE &&
 242       start_position.y < scroll_y + Y_OFFSCREEN_DISTANCE) {
 243     dir = RIGHT;
 244     set_state(STATE_ACTIVE);
 245     activate();
 246   } else if (start_position.x > scroll_x &&
 247       start_position.x < scroll_x + X_OFFSCREEN_DISTANCE &&
 248       start_position.y > scroll_y - Y_OFFSCREEN_DISTANCE &&
 249       start_position.y < scroll_y + Y_OFFSCREEN_DISTANCE) {
 250     dir = LEFT;
 251     set_state(STATE_ACTIVE);
 252     activate();
 253   } else if (start_position.x > scroll_x - X_OFFSCREEN_DISTANCE &&
 254       start_position.x < scroll_x + X_OFFSCREEN_DISTANCE &&
 255       ((start_position.y > scroll_y &&
 256         start_position.y < scroll_y + Y_OFFSCREEN_DISTANCE) ||
 257        (start_position.y > scroll_y - Y_OFFSCREEN_DISTANCE &&
 258         start_position.y < scroll_y))) {
 259     dir = start_position.x < scroll_x ? RIGHT : LEFT;
 260     set_state(STATE_ACTIVE);
 261     activate();
 262   } else if(state == STATE_INIT
 263       && start_position.x > scroll_x - X_OFFSCREEN_DISTANCE
 264       && start_position.x < scroll_x + X_OFFSCREEN_DISTANCE
 265       && start_position.y > scroll_y - Y_OFFSCREEN_DISTANCE
 266       && start_position.y < scroll_y + Y_OFFSCREEN_DISTANCE) {
 267     dir = LEFT;
 268     set_state(STATE_ACTIVE);
 269     activate();
 270   }
 271 }