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