src/object/bonus_block.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmail.com>
   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 "object/bonus_block.hpp"
  18
  19 #include "audio/sound_manager.hpp"
  20 #include "badguy/badguy.hpp"
  21 #include "lisp/list_iterator.hpp"
  22 #include "object/flower.hpp"
  23 #include "object/bouncy_coin.hpp"
  24 #include "object/coin_explode.hpp"
  25 #include "object/coin_rain.hpp"
  26 #include "object/growup.hpp"
  27 #include "object/oneup.hpp"
  28 #include "object/player.hpp"
  29 #include "object/portable.hpp"
  30 #include "object/powerup.hpp"
  31 #include "object/specialriser.hpp"
  32 #include "object/star.hpp"
  33 #include "object/trampoline.hpp"
  34 #include "sprite/sprite_manager.hpp"
  35 #include "supertux/constants.hpp"
  36 #include "supertux/level.hpp"
  37 #include "supertux/object_factory.hpp"
  38 #include "supertux/sector.hpp"
  39
  40 #include <stdexcept>
  41
  42 BonusBlock::BonusBlock(const Vector& pos, int data) :
  43   Block(SpriteManager::current()->create("images/objects/bonus_block/bonusblock.sprite")),
  44   contents(),
  45   object(),
  46   hit_counter(1),
  47   sprite_name(),
  48   script(),
  49   lightsprite()
  50 {
  51   bbox.set_pos(pos);
  52   sprite->set_action("normal");
  53   switch(data) {
  54     case 1: contents = CONTENT_COIN; break;
  55     case 2: contents = CONTENT_FIREGROW; break;
  56     case 3: contents = CONTENT_STAR; break;
  57     case 4: contents = CONTENT_1UP; break;
  58     case 5: contents = CONTENT_ICEGROW; break;
  59     case 6: contents = CONTENT_LIGHT;
  60       SoundManager::current()->preload("sounds/switch.ogg");
  61       lightsprite=Surface::create("/images/objects/lightmap_light/bonusblock_light.png");
  62       break;
  63     case 7: contents = CONTENT_TRAMPOLINE;
  64       //object = new Trampoline(get_pos(), false); //needed if this is to be moved to custom
  65       break;
  66     case 8: contents = CONTENT_CUSTOM;
  67       object = std::make_shared<Trampoline>(get_pos(), true);
  68       break;
  69     case 9: contents = CONTENT_CUSTOM;
  70       object = std::make_shared<Rock>(get_pos(), "images/objects/rock/rock.sprite");
  71       break;
  72     case 10: contents = CONTENT_RAIN; break;
  73     case 11: contents = CONTENT_EXPLODE; break;
  74     case 12: contents = CONTENT_CUSTOM;
  75       object = std::make_shared<PowerUp>(get_pos(), "images/powerups/potions/red-potion.sprite");
  76       break;
  77     case 13: contents = CONTENT_AIRGROW; break;
  78     case 14: contents = CONTENT_EARTHGROW; break;
  79     default:
  80       log_warning << "Invalid box contents" << std::endl;
  81       contents = CONTENT_COIN;
  82       break;
  83   }
  84 }
  85
  86 BonusBlock::BonusBlock(const Reader& lisp) :
  87   Block(SpriteManager::current()->create("images/objects/bonus_block/bonusblock.sprite")),
  88   contents(),
  89   object(0),
  90   hit_counter(1),
  91   sprite_name(),
  92   script(),
  93   lightsprite()
  94 {
  95   Vector pos;
  96
  97   contents = CONTENT_COIN;
  98   lisp::ListIterator iter(&lisp);
  99   while(iter.next()) {
 100     const std::string& token = iter.item();
 101     if(token == "x") {
 102       iter.value()->get(pos.x);
 103     } else if(token == "y") {
 104       iter.value()->get(pos.y);
 105     } else if(token == "sprite") {
 106       iter.value()->get(sprite_name);
 107       sprite = SpriteManager::current()->create(sprite_name);
 108     } else if(token == "count") {
 109       iter.value()->get(hit_counter);
 110     } else if(token == "script") {
 111       iter.value()->get(script);
 112     } else if(token == "contents") {
 113       std::string contentstring;
 114       iter.value()->get(contentstring);
 115       if(contentstring == "coin") {
 116         contents = CONTENT_COIN;
 117       } else if(contentstring == "firegrow") {
 118         contents = CONTENT_FIREGROW;
 119       } else if(contentstring == "icegrow") {
 120         contents = CONTENT_ICEGROW;
 121       } else if(contentstring == "airgrow") {
 122         contents = CONTENT_AIRGROW;
 123       } else if(contentstring == "earthgrow") {
 124         contents = CONTENT_EARTHGROW;
 125       } else if(contentstring == "star") {
 126         contents = CONTENT_STAR;
 127       } else if(contentstring == "1up") {
 128         contents = CONTENT_1UP;
 129       } else if(contentstring == "custom") {
 130         contents = CONTENT_CUSTOM;
 131       } else if(contentstring == "script") { // use when bonusblock is to contain ONLY a script
 132         contents = CONTENT_SCRIPT;
 133       } else if(contentstring == "light") {
 134         contents = CONTENT_LIGHT;
 135         SoundManager::current()->preload("sounds/switch.ogg");
 136       } else if(contentstring == "trampoline") {
 137         contents = CONTENT_TRAMPOLINE;
 138       } else if(contentstring == "rain") {
 139         contents = CONTENT_RAIN;
 140       } else if(contentstring == "explode") {
 141         contents = CONTENT_EXPLODE;
 142       } else {
 143         log_warning << "Invalid box contents '" << contentstring << "'" << std::endl;
 144       }
 145     } else {
 146       if(contents == CONTENT_CUSTOM) {
 147         GameObjectPtr game_object = ObjectFactory::instance().create(token, *(iter.lisp()));
 148         object = std::dynamic_pointer_cast<MovingObject>(game_object);
 149         if(object == 0)
 150           throw std::runtime_error(
 151             "Only MovingObjects are allowed inside BonusBlocks");
 152       } else {
 153         log_warning << "Invalid element '" << token << "' in bonusblock" << std::endl;
 154       }
 155     }
 156   }
 157
 158   if(contents == CONTENT_CUSTOM && object == 0)
 159     throw std::runtime_error("Need to specify content object for custom block");
 160   if(contents == CONTENT_LIGHT)
 161     lightsprite = Surface::create("/images/objects/lightmap_light/bonusblock_light.png");
 162
 163   bbox.set_pos(pos);
 164 }
 165
 166 BonusBlock::~BonusBlock()
 167 {
 168 }
 169
 170 void
 171 BonusBlock::hit(Player & player)
 172 {
 173   try_open(&player);
 174 }
 175
 176 HitResponse
 177 BonusBlock::collision(GameObject& other, const CollisionHit& hit_){
 178
 179   Player* player = dynamic_cast<Player*> (&other);
 180   if (player) {
 181     if (player->does_buttjump)
 182       try_drop(player);
 183   }
 184
 185   BadGuy* badguy = dynamic_cast<BadGuy*> (&other);
 186   if(badguy) {
 187     // hit contains no information for collisions with blocks.
 188     // Badguy's bottom has to be below the top of the block
 189     // SHIFT_DELTA is required to slide over one tile gaps.
 190     if( badguy->can_break() && ( badguy->get_bbox().get_bottom() > get_bbox().get_top() + SHIFT_DELTA ) ){
 191       try_open(player);
 192     }
 193   }
 194   Portable* portable = dynamic_cast<Portable*> (&other);
 195   if(portable) {
 196     MovingObject* moving = dynamic_cast<MovingObject*> (&other);
 197     if(moving->get_bbox().get_top() > get_bbox().get_bottom() - SHIFT_DELTA) {
 198       try_open(player);
 199     }
 200   }
 201   return Block::collision(other, hit_);
 202 }
 203
 204 void
 205 BonusBlock::try_open(Player *player)
 206 {
 207   if(sprite->get_action() == "empty") {
 208     SoundManager::current()->play("sounds/brick.wav");
 209     return;
 210   }
 211
 212   Sector* sector = Sector::current();
 213   assert(sector);
 214
 215   if (player == NULL)
 216     player = sector->player;
 217
 218   if (player == NULL)
 219     return;
 220
 221   Direction direction = (player->get_bbox().get_middle().x > get_bbox().get_middle().x) ? LEFT : RIGHT;
 222
 223   switch(contents) {
 224     case CONTENT_COIN:
 225     {
 226       Sector::current()->add_object(std::make_shared<BouncyCoin>(get_pos(), true));
 227       player->get_status()->add_coins(1);
 228       if (hit_counter != 0)
 229         Sector::current()->get_level()->stats.coins++;
 230       break;
 231     }
 232
 233     case CONTENT_FIREGROW:
 234     {
 235       if(player->get_status()->bonus == NO_BONUS) {
 236         auto riser = std::make_shared<SpecialRiser>(get_pos(), std::make_shared<GrowUp>(direction));
 237         sector->add_object(riser);
 238       } else {
 239         auto riser = std::make_shared<SpecialRiser>(
 240           get_pos(), std::make_shared<Flower>(FIRE_BONUS));
 241         sector->add_object(riser);
 242       }
 243       SoundManager::current()->play("sounds/upgrade.wav");
 244       break;
 245     }
 246
 247     case CONTENT_ICEGROW:
 248     {
 249       if(player->get_status()->bonus == NO_BONUS) {
 250         auto riser = std::make_shared<SpecialRiser>(get_pos(), std::make_shared<GrowUp>(direction));
 251         sector->add_object(riser);
 252       } else {
 253         auto riser = std::make_shared<SpecialRiser>(
 254           get_pos(), std::make_shared<Flower>(ICE_BONUS));
 255         sector->add_object(riser);
 256       }
 257       SoundManager::current()->play("sounds/upgrade.wav");
 258       break;
 259     }
 260
 261     case CONTENT_AIRGROW:
 262     {
 263       if(player->get_status()->bonus == NO_BONUS) {
 264         auto riser = std::make_shared<SpecialRiser>(get_pos(), std::make_shared<GrowUp>(direction));
 265         sector->add_object(riser);
 266       } else {
 267         auto riser = std::make_shared<SpecialRiser>(
 268           get_pos(), std::make_shared<Flower>(AIR_BONUS));
 269         sector->add_object(riser);
 270       }
 271       SoundManager::current()->play("sounds/upgrade.wav");
 272       break;
 273     }
 274
 275     case CONTENT_EARTHGROW:
 276     {
 277       if(player->get_status()->bonus == NO_BONUS) {
 278         auto riser = std::make_shared<SpecialRiser>(get_pos(), std::make_shared<GrowUp>(direction));
 279         sector->add_object(riser);
 280       } else {
 281         auto riser = std::make_shared<SpecialRiser>(
 282           get_pos(), std::make_shared<Flower>(EARTH_BONUS));
 283         sector->add_object(riser);
 284       }
 285       SoundManager::current()->play("sounds/upgrade.wav");
 286       break;
 287     }
 288
 289     case CONTENT_STAR:
 290     {
 291       sector->add_object(std::make_shared<Star>(get_pos() + Vector(0, -32), direction));
 292       SoundManager::current()->play("sounds/upgrade.wav");
 293       break;
 294     }
 295
 296     case CONTENT_1UP:
 297     {
 298       sector->add_object(std::make_shared<OneUp>(get_pos(), direction));
 299       SoundManager::current()->play("sounds/upgrade.wav");
 300       break;
 301     }
 302
 303     case CONTENT_CUSTOM:
 304     {
 305       auto riser = std::make_shared<SpecialRiser>(get_pos(), object);
 306       object = 0;
 307       sector->add_object(riser);
 308       SoundManager::current()->play("sounds/upgrade.wav");
 309       break;
 310     }
 311
 312     case CONTENT_SCRIPT:
 313     { break; } // because scripts always run, this prevents default contents from being assumed
 314
 315     case CONTENT_LIGHT:
 316     {
 317       if(sprite->get_action() == "on")
 318         sprite->set_action("off");
 319       else
 320         sprite->set_action("on");
 321       SoundManager::current()->play("sounds/switch.ogg");
 322       break;
 323     }
 324     case CONTENT_TRAMPOLINE:
 325     {
 326       auto riser = std::make_shared<SpecialRiser>(get_pos(), std::make_shared<Trampoline>(get_pos(), false));
 327       sector->add_object(riser);
 328       SoundManager::current()->play("sounds/upgrade.wav");
 329       break;
 330     }
 331     case CONTENT_RAIN:
 332     {
 333       hit_counter = 1; // multiple hits of coin rain is not allowed
 334       Sector::current()->add_object(std::make_shared<CoinRain>(get_pos(), true));
 335       SoundManager::current()->play("sounds/upgrade.wav");
 336       break;
 337     }
 338     case CONTENT_EXPLODE:
 339     {
 340       hit_counter = 1; // multiple hits of coin explode is not allowed
 341       Sector::current()->add_object(std::make_shared<CoinExplode>(get_pos() + Vector (0, -40)));
 342       SoundManager::current()->play("sounds/upgrade.wav");
 343       break;
 344     }
 345   }
 346
 347   if(script != "") { // scripts always run if defined
 348     std::istringstream stream(script);
 349     Sector::current()->run_script(stream, "BonusBlockScript");
 350   }
 351
 352   start_bounce(player);
 353   if(hit_counter <= 0 || contents == CONTENT_LIGHT){ //use 0 to allow infinite hits
 354   }else if(hit_counter == 1){
 355     sprite->set_action("empty");
 356   }else{
 357     hit_counter--;
 358   }
 359 }
 360
 361 void
 362 BonusBlock::try_drop(Player *player)
 363 {
 364   if(sprite->get_action() == "empty") {
 365     SoundManager::current()->play("sounds/brick.wav");
 366     return;
 367   }
 368
 369   Sector* sector = Sector::current();
 370   assert(sector);
 371
 372   // First what's below the bonus block, if solid send it up anyway (excepting doll)
 373   Rectf dest_;
 374   dest_.p1.x = bbox.get_left() + 1;
 375   dest_.p1.y = bbox.get_bottom() + 1;
 376   dest_.p2.x = bbox.get_right() - 1;
 377   dest_.p2.y = dest_.p1.y + 30;
 378   if (!Sector::current()->is_free_of_statics(dest_, this, true) && !(contents == CONTENT_1UP)) {
 379     try_open(player);
 380     return;
 381   }
 382
 383   if (player == NULL)
 384     player = sector->player;
 385
 386   if (player == NULL)
 387     return;
 388
 389   Direction direction = (player->get_bbox().get_middle().x > get_bbox().get_middle().x) ? LEFT : RIGHT;
 390
 391   bool countdown = false;
 392
 393   switch(contents) {
 394     case CONTENT_COIN:
 395     {
 396       try_open(player);
 397       break;
 398     }
 399
 400     case CONTENT_FIREGROW:
 401     {
 402       sector->add_object(std::make_shared<PowerUp>(get_pos() + Vector(0, 32), "images/powerups/fireflower/fireflower.sprite"));
 403       SoundManager::current()->play("sounds/upgrade.wav");
 404       countdown = true;
 405       break;
 406     }
 407
 408     case CONTENT_ICEGROW:
 409     {
 410       sector->add_object(std::make_shared<PowerUp>(get_pos() + Vector(0, 32), "images/powerups/iceflower/iceflower.sprite"));
 411       SoundManager::current()->play("sounds/upgrade.wav");
 412       countdown = true;
 413       break;
 414     }
 415
 416     case CONTENT_AIRGROW:
 417     {
 418       sector->add_object(std::make_shared<PowerUp>(get_pos() + Vector(0, 32), "images/powerups/airflower/airflower.sprite"));
 419       SoundManager::current()->play("sounds/upgrade.wav");
 420       countdown = true;
 421       break;
 422     }
 423
 424     case CONTENT_EARTHGROW:
 425     {
 426       sector->add_object(std::make_shared<PowerUp>(get_pos() + Vector(0, 32), "images/powerups/earthflower/earthflower.sprite"));
 427       SoundManager::current()->play("sounds/upgrade.wav");
 428       countdown = true;
 429       break;
 430     }
 431
 432     case CONTENT_STAR:
 433     {
 434       sector->add_object(std::make_shared<Star>(get_pos() + Vector(0, 32), direction));
 435       SoundManager::current()->play("sounds/upgrade.wav");
 436       countdown = true;
 437       break;
 438     }
 439
 440     case CONTENT_1UP:
 441     {
 442       sector->add_object(std::make_shared<OneUp>(get_pos(), DOWN));
 443       SoundManager::current()->play("sounds/upgrade.wav");
 444       countdown = true;
 445       break;
 446     }
 447
 448     case CONTENT_CUSTOM:
 449     {
 450       //NOTE: non-portable trampolines could be moved to CONTENT_CUSTOM, but they should not drop
 451       object->set_pos(get_pos() +  Vector(0, 32));
 452       sector->add_object(object);
 453       object = 0;
 454       SoundManager::current()->play("sounds/upgrade.wav");
 455       countdown = true;
 456       break;
 457     }
 458
 459     case CONTENT_SCRIPT:
 460     { break; } // because scripts always run, this prevents default contents from being assumed
 461
 462     case CONTENT_LIGHT:
 463     {
 464       try_open(player);
 465       break;
 466     }
 467     case CONTENT_TRAMPOLINE:
 468     {
 469       try_open(player);
 470       break;
 471     }
 472     case CONTENT_RAIN:
 473     {
 474       try_open(player);
 475       break;
 476     }
 477     case CONTENT_EXPLODE:
 478     {
 479       hit_counter = 1; // multiple hits of coin explode is not allowed
 480       Sector::current()->add_object(std::make_shared<CoinExplode>(get_pos() + Vector (0, 40)));
 481       SoundManager::current()->play("sounds/upgrade.wav");
 482       countdown = true;
 483       break;
 484     }
 485   }
 486
 487   if(script != "") { // scripts always run if defined
 488     std::istringstream stream(script);
 489     Sector::current()->run_script(stream, "powerup-script");
 490   }
 491
 492   if(countdown){ // only decrease hit counter if try_open was not called
 493     if(hit_counter == 1){
 494       sprite->set_action("empty");
 495     }else{
 496       hit_counter--;
 497     }
 498   }
 499 }
 500
 501 void
 502 BonusBlock::draw(DrawingContext& context){
 503   // do the regular drawing first
 504   Block::draw(context);
 505   // then Draw the light if on.
 506   if(sprite->get_action() == "on") {
 507     Vector pos = get_pos() + (bbox.get_size().as_vector() - lightsprite->get_size()) / 2;
 508     context.push_target();
 509     context.set_target(DrawingContext::LIGHTMAP);
 510     context.draw_surface(lightsprite, pos, 10);
 511     context.pop_target();
 512   }
 513 }
 514 /* EOF */