src/badguy/badguy.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "badguy/badguy.hpp"
  18
  19 #include "audio/sound_manager.hpp"
  20 #include "object/bullet.hpp"
  21 #include "object/player.hpp"
  22 #include "supertux/level.hpp"
  23 #include "supertux/sector.hpp"
  24 #include "supertux/tile.hpp"
  25
  26 #include <math.h>
  27
  28 static const float SQUISH_TIME = 2;
  29
  30 static const float X_OFFSCREEN_DISTANCE = 1600;
  31 static const float Y_OFFSCREEN_DISTANCE = 1200;
  32
  33 BadGuy::BadGuy(const Vector& pos, const std::string& sprite_name, int layer) :
  34   MovingSprite(pos, sprite_name, layer, COLGROUP_DISABLED),
  35   countMe(true),
  36   is_initialized(false),
  37   start_position(),
  38   dir(LEFT),
  39   start_dir(AUTO),
  40   frozen(false),
  41   ignited(false),
  42   dead_script(),
  43   state(STATE_INIT),
  44   is_active_flag(),
  45   state_timer(),
  46   on_ground_flag(false),
  47   floor_normal(),
  48   colgroup_active(COLGROUP_MOVING)
  49 {
  50   start_position = bbox.p1;
  51
  52   sound_manager->preload("sounds/squish.wav");
  53   sound_manager->preload("sounds/fall.wav");
  54
  55   dir = (start_dir == AUTO) ? LEFT : start_dir;
  56 }
  57
  58 BadGuy::BadGuy(const Vector& pos, Direction direction, const std::string& sprite_name, int layer) :
  59   MovingSprite(pos, sprite_name, layer, COLGROUP_DISABLED),
  60   countMe(true),
  61   is_initialized(false),
  62   start_position(),
  63   dir(direction),
  64   start_dir(direction),
  65   frozen(false),
  66   ignited(false),
  67   dead_script(),
  68   state(STATE_INIT),
  69   is_active_flag(),
  70   state_timer(),
  71   on_ground_flag(false),
  72   floor_normal(),
  73   colgroup_active(COLGROUP_MOVING)
  74 {
  75   start_position = bbox.p1;
  76
  77   sound_manager->preload("sounds/squish.wav");
  78   sound_manager->preload("sounds/fall.wav");
  79
  80   dir = (start_dir == AUTO) ? LEFT : start_dir;
  81 }
  82
  83 BadGuy::BadGuy(const Reader& reader, const std::string& sprite_name, int layer) :
  84   MovingSprite(reader, sprite_name, layer, COLGROUP_DISABLED),
  85   countMe(true),
  86   is_initialized(false),
  87   start_position(),
  88   dir(LEFT),
  89   start_dir(AUTO),
  90   frozen(false),
  91   ignited(false),
  92   dead_script(),
  93   state(STATE_INIT),
  94   is_active_flag(),
  95   state_timer(),
  96   on_ground_flag(false),
  97   floor_normal(),
  98   colgroup_active(COLGROUP_MOVING)
  99 {
 100   start_position = bbox.p1;
 101
 102   std::string dir_str = "auto";
 103   reader.get("direction", dir_str);
 104   start_dir = str2dir( dir_str );
 105   dir = start_dir;
 106
 107   reader.get("dead-script", dead_script);
 108
 109   sound_manager->preload("sounds/squish.wav");
 110   sound_manager->preload("sounds/fall.wav");
 111
 112   dir = (start_dir == AUTO) ? LEFT : start_dir;
 113 }
 114
 115 void
 116 BadGuy::draw(DrawingContext& context)
 117 {
 118   if(!sprite.get())
 119     return;
 120   if(state == STATE_INIT || state == STATE_INACTIVE)
 121     return;
 122   if(state == STATE_FALLING) {
 123     DrawingEffect old_effect = context.get_drawing_effect();
 124     context.set_drawing_effect((DrawingEffect) (old_effect | VERTICAL_FLIP));
 125     sprite->draw(context, get_pos(), layer);
 126     context.set_drawing_effect(old_effect);
 127   } else {
 128     sprite->draw(context, get_pos(), layer);
 129   }
 130 }
 131
 132 void
 133 BadGuy::update(float elapsed_time)
 134 {
 135   if(!Sector::current()->inside(bbox)) {
 136     is_active_flag = false;
 137     remove_me();
 138     return;
 139   }
 140   if ((state != STATE_INACTIVE) && is_offscreen()) {
 141     if (state == STATE_ACTIVE) deactivate();
 142     set_state(STATE_INACTIVE);
 143   }
 144
 145   switch(state) {
 146     case STATE_ACTIVE:
 147       is_active_flag = true;
 148       active_update(elapsed_time);
 149       break;
 150     case STATE_INIT:
 151     case STATE_INACTIVE:
 152       is_active_flag = false;
 153       inactive_update(elapsed_time);
 154       try_activate();
 155       break;
 156     case STATE_SQUISHED:
 157       is_active_flag = false;
 158       if(state_timer.check()) {
 159         remove_me();
 160         break;
 161       }
 162       movement = physic.get_movement(elapsed_time);
 163       break;
 164     case STATE_FALLING:
 165       is_active_flag = false;
 166       movement = physic.get_movement(elapsed_time);
 167       break;
 168   }
 169
 170   on_ground_flag = false;
 171 }
 172
 173 Direction
 174 BadGuy::str2dir( std::string dir_str )
 175 {
 176   if( dir_str == "auto" )
 177     return AUTO;
 178   if( dir_str == "left" )
 179     return LEFT;
 180   if( dir_str == "right" )
 181     return RIGHT;
 182
 183   //default to "auto"
 184   log_warning << "Badguy::str2dir: unknown direction \"" << dir_str << "\"" << std::endl;;
 185   return AUTO;
 186 }
 187
 188 void
 189 BadGuy::initialize()
 190 {
 191 }
 192
 193 void
 194 BadGuy::activate()
 195 {
 196 }
 197
 198 void
 199 BadGuy::deactivate()
 200 {
 201 }
 202
 203 void
 204 BadGuy::active_update(float elapsed_time)
 205 {
 206   movement = physic.get_movement(elapsed_time);
 207 }
 208
 209 void
 210 BadGuy::inactive_update(float )
 211 {
 212 }
 213
 214 void
 215 BadGuy::collision_tile(uint32_t tile_attributes)
 216 {
 217   if(tile_attributes & Tile::HURTS) {
 218     if (tile_attributes & Tile::FIRE) {
 219       if (is_flammable()) ignite();
 220     }
 221     else if (tile_attributes & Tile::ICE) {
 222       if (is_freezable()) freeze();
 223     }
 224     else {
 225       kill_fall();
 226     }
 227   }
 228 }
 229
 230 HitResponse
 231 BadGuy::collision(GameObject& other, const CollisionHit& hit)
 232 {
 233   if (!is_active()) return ABORT_MOVE;
 234
 235   BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
 236   if(badguy && badguy->is_active() && badguy->get_group() == COLGROUP_MOVING) {
 237
 238     // hit from above?
 239     if (badguy->get_bbox().p2.y < (bbox.p1.y + 16)) {
 240       if(collision_squished(*badguy)) {
 241         return ABORT_MOVE;
 242       }
 243     }
 244
 245     return collision_badguy(*badguy, hit);
 246   }
 247
 248   Player* player = dynamic_cast<Player*> (&other);
 249   if(player) {
 250
 251     // hit from above?
 252     if (player->get_bbox().p2.y < (bbox.p1.y + 16)) {
 253       if(collision_squished(*player)) {
 254         return ABORT_MOVE;
 255       }
 256     }
 257
 258     return collision_player(*player, hit);
 259   }
 260
 261   Bullet* bullet = dynamic_cast<Bullet*> (&other);
 262   if(bullet)
 263     return collision_bullet(*bullet, hit);
 264
 265   return FORCE_MOVE;
 266 }
 267
 268 void
 269 BadGuy::collision_solid(const CollisionHit& hit)
 270 {
 271   physic.set_velocity_x(0);
 272   physic.set_velocity_y(0);
 273   update_on_ground_flag(hit);
 274 }
 275
 276 HitResponse
 277 BadGuy::collision_player(Player& player, const CollisionHit& )
 278 {
 279   if(player.is_invincible()) {
 280     kill_fall();
 281     return ABORT_MOVE;
 282   }
 283
 284   if(frozen)
 285     unfreeze();
 286   player.kill(false);
 287   return FORCE_MOVE;
 288 }
 289
 290 HitResponse
 291 BadGuy::collision_badguy(BadGuy& , const CollisionHit& )
 292 {
 293   return FORCE_MOVE;
 294 }
 295
 296 bool
 297 BadGuy::collision_squished(GameObject& )
 298 {
 299   return false;
 300 }
 301
 302 HitResponse
 303 BadGuy::collision_bullet(Bullet& bullet, const CollisionHit& hit)
 304 {
 305   if (is_frozen()) {
 306     if(bullet.get_type() == FIRE_BONUS) {
 307       // fire bullet thaws frozen badguys
 308       unfreeze();
 309       bullet.remove_me();
 310       return ABORT_MOVE;
 311     } else {
 312       // other bullets ricochet
 313       bullet.ricochet(*this, hit);
 314       return FORCE_MOVE;
 315     }
 316   }
 317   else if (is_ignited()) {
 318     if(bullet.get_type() == ICE_BONUS) {
 319       // ice bullets extinguish ignited badguys
 320       extinguish();
 321       bullet.remove_me();
 322       return ABORT_MOVE;
 323     } else {
 324       // other bullets are absorbed by ignited badguys
 325       bullet.remove_me();
 326       return FORCE_MOVE;
 327     }
 328   }
 329   else if(bullet.get_type() == FIRE_BONUS && is_flammable()) {
 330     // fire bullets ignite flammable badguys
 331     ignite();
 332     bullet.remove_me();
 333     return ABORT_MOVE;
 334   }
 335   else if(bullet.get_type() == ICE_BONUS && is_freezable()) {
 336     // ice bullets freeze freezable badguys
 337     freeze();
 338     bullet.remove_me();
 339     return ABORT_MOVE;
 340   }
 341   else {
 342     // in all other cases, bullets ricochet
 343     bullet.ricochet(*this, hit);
 344     return FORCE_MOVE;
 345   }
 346 }
 347
 348 void
 349 BadGuy::kill_squished(GameObject& object)
 350 {
 351   sound_manager->play("sounds/squish.wav", get_pos());
 352   physic.enable_gravity(true);
 353   physic.set_velocity_x(0);
 354   physic.set_velocity_y(0);
 355   set_state(STATE_SQUISHED);
 356   set_group(COLGROUP_MOVING_ONLY_STATIC);
 357   Player* player = dynamic_cast<Player*>(&object);
 358   if (player) {
 359     player->bounce(*this);
 360   }
 361
 362   // start dead-script
 363   run_dead_script();
 364 }
 365
 366 void
 367 BadGuy::kill_fall()
 368 {
 369   sound_manager->play("sounds/fall.wav", get_pos());
 370   physic.set_velocity_y(0);
 371   physic.set_acceleration_y(0);
 372   physic.enable_gravity(true);
 373   set_state(STATE_FALLING);
 374
 375   // start dead-script
 376   run_dead_script();
 377 }
 378
 379 void
 380 BadGuy::run_dead_script()
 381 {
 382   if (countMe)
 383     Sector::current()->get_level()->stats.badguys++;
 384
 385   countMe = false;
 386
 387   // start dead-script
 388   if(dead_script != "") {
 389     std::istringstream stream(dead_script);
 390     Sector::current()->run_script(stream, "dead-script");
 391   }
 392 }
 393
 394 void
 395 BadGuy::set_state(State state)
 396 {
 397   if(this->state == state)
 398     return;
 399
 400   State laststate = this->state;
 401   this->state = state;
 402   switch(state) {
 403     case STATE_SQUISHED:
 404       state_timer.start(SQUISH_TIME);
 405       break;
 406     case STATE_ACTIVE:
 407       set_group(colgroup_active);
 408       //bbox.set_pos(start_position);
 409       break;
 410     case STATE_INACTIVE:
 411       // was the badguy dead anyway?
 412       if(laststate == STATE_SQUISHED || laststate == STATE_FALLING) {
 413         remove_me();
 414       }
 415       set_group(COLGROUP_DISABLED);
 416       break;
 417     case STATE_FALLING:
 418       set_group(COLGROUP_DISABLED);
 419       break;
 420     default:
 421       break;
 422   }
 423 }
 424
 425 bool
 426 BadGuy::is_offscreen()
 427 {
 428   Player* player = get_nearest_player();
 429   if (!player) return false;
 430   Vector dist = player->get_bbox().get_middle() - get_bbox().get_middle();
 431   if ((dist.x <= X_OFFSCREEN_DISTANCE+32) && (dist.y <= Y_OFFSCREEN_DISTANCE+32)) {
 432     return false;
 433   }
 434   return true;
 435 }
 436
 437 void
 438 BadGuy::try_activate()
 439 {
 440   // In SuperTux 0.1.x, Badguys were activated when Tux<->Badguy center distance was approx. <= ~668px
 441   // This doesn't work for wide-screen monitors which give us a virt. res. of approx. 1066px x 600px
 442   Player* player = get_nearest_player();
 443   if (!player) return;
 444   Vector dist = player->get_bbox().get_middle() - get_bbox().get_middle();
 445   if ((fabsf(dist.x) <= X_OFFSCREEN_DISTANCE) && (fabsf(dist.y) <= Y_OFFSCREEN_DISTANCE)) {
 446     set_state(STATE_ACTIVE);
 447     if (!is_initialized) {
 448
 449       // if starting direction was set to AUTO, this is our chance to re-orient the badguy
 450       if (start_dir == AUTO) {
 451         Player* player = get_nearest_player();
 452         if (player && (player->get_bbox().p1.x > get_bbox().p2.x)) {
 453           dir = RIGHT;
 454         } else {
 455           dir = LEFT;
 456         }
 457       }
 458
 459       initialize();
 460       is_initialized = true;
 461     }
 462     activate();
 463   }
 464 }
 465
 466 bool
 467 BadGuy::might_fall(int height)
 468 {
 469   // make sure we check for at least a 1-pixel fall
 470   assert(height > 0);
 471
 472   float x1;
 473   float x2;
 474   float y1 = bbox.p2.y + 1;
 475   float y2 = bbox.p2.y + 1 + height;
 476   if (dir == LEFT) {
 477     x1 = bbox.p1.x - 1;
 478     x2 = bbox.p1.x - 1;
 479   } else {
 480     x1 = bbox.p2.x + 1;
 481     x2 = bbox.p2.x + 1;
 482   }
 483   return Sector::current()->is_free_of_statics(Rect(x1, y1, x2, y2));
 484 }
 485
 486 Player*
 487 BadGuy::get_nearest_player()
 488 {
 489   // FIXME: does not really return nearest player
 490
 491   std::vector<Player*> players = Sector::current()->get_players();
 492   for (std::vector<Player*>::iterator playerIter = players.begin(); playerIter != players.end(); ++playerIter) {
 493     Player* player = *playerIter;
 494     if (player->is_dying() || player->is_dead()) continue;
 495     return player;
 496   }
 497
 498   return 0;
 499 }
 500
 501 void
 502 BadGuy::update_on_ground_flag(const CollisionHit& hit)
 503 {
 504   if (hit.bottom) {
 505     on_ground_flag = true;
 506     floor_normal = hit.slope_normal;
 507   }
 508 }
 509
 510 bool
 511 BadGuy::on_ground()
 512 {
 513   return on_ground_flag;
 514 }
 515
 516 bool
 517 BadGuy::is_active()
 518 {
 519   return is_active_flag;
 520 }
 521
 522 Vector
 523 BadGuy::get_floor_normal()
 524 {
 525   return floor_normal;
 526 }
 527
 528 void
 529 BadGuy::freeze()
 530 {
 531   set_group(COLGROUP_MOVING_STATIC);
 532   frozen = true;
 533 }
 534
 535 void
 536 BadGuy::unfreeze()
 537 {
 538   set_group(colgroup_active);
 539   frozen = false;
 540 }
 541
 542 bool
 543 BadGuy::is_freezable() const
 544 {
 545   return false;
 546 }
 547
 548 bool
 549 BadGuy::is_frozen() const
 550 {
 551   return frozen;
 552 }
 553
 554 void
 555 BadGuy::ignite()
 556 {
 557   kill_fall();
 558 }
 559
 560 void
 561 BadGuy::extinguish()
 562 {
 563 }
 564
 565 bool
 566 BadGuy::is_flammable() const
 567 {
 568   return true;
 569 }
 570
 571 bool
 572 BadGuy::is_ignited() const
 573 {
 574   return ignited;
 575 }
 576
 577 void
 578 BadGuy::set_colgroup_active(CollisionGroup group)
 579 {
 580   this->colgroup_active = group;
 581   if (state == STATE_ACTIVE) set_group(group);
 582 }
 583
 584 /* EOF */