X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fobject%2Funstable_tile.cpp;h=50ba0c624f270c7e162db35de38108233cdc3f76;hb=01855433649374b48523f5eb7e6cf204391c36ca;hp=8a61d09c45db7326da1d34d97a2aacb5d1559e70;hpb=15c5a91ee89272dfda3666e2fed67e06d650d0bf;p=supertux.git diff --git a/src/object/unstable_tile.cpp b/src/object/unstable_tile.cpp index 8a61d09c4..50ba0c624 100644 --- a/src/object/unstable_tile.cpp +++ b/src/object/unstable_tile.cpp @@ -1,12 +1,12 @@ -// $Id$ -// -// SuperTux +// SuperTux - Unstable Tile // Copyright (C) 2006 Matthias Braun +// Copyright (C) 2006 Christoph Sommer +// Copyright (C) 2010 Florian Forster // -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 2 -// of the License, or (at your option) any later version. +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -14,76 +14,147 @@ // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// along with this program. If not, see . -#include +#include "object/unstable_tile.hpp" -#include "unstable_tile.hpp" -#include "lisp/lisp.hpp" -#include "object_factory.hpp" -#include "player.hpp" -#include "sector.hpp" -#include "resources.hpp" +#include "object/explosion.hpp" +#include "object/player.hpp" #include "sprite/sprite.hpp" -#include "random_generator.hpp" - -static const float CRACKTIME = 0.3; -static const float FALLTIME = 0.8; +#include "supertux/constants.hpp" +#include "supertux/object_factory.hpp" -UnstableTile::UnstableTile(const lisp::Lisp& lisp) - : MovingSprite(lisp, "images/objects/unstable_tile/unstable_tile.sprite", LAYER_TILES, COLGROUP_STATIC), hit(false), falling(false) +UnstableTile::UnstableTile(const Reader& lisp) : + MovingSprite(lisp, LAYER_TILES, COLGROUP_STATIC), + physic(), + state(STATE_NORMAL), + slowfall_timer() { - flags |= FLAG_SOLID; + sprite->set_action("normal"); + physic.set_gravity_modifier (.98); + physic.enable_gravity (false); } HitResponse -UnstableTile::collision(GameObject& other, const CollisionHit& hitdata) +UnstableTile::collision(GameObject& other, const CollisionHit& ) { - if(hitdata.normal.y < 0.8) - return FORCE_MOVE; - - Player* player = dynamic_cast (&other); - if(player) - hit = true; + if(state == STATE_NORMAL) { + Player* player = dynamic_cast (&other); + if(player != NULL && + player->get_bbox().get_bottom() < get_bbox().get_top() + SHIFT_DELTA) { + shake (); + } + if (dynamic_cast (&other)) { + shake (); + } + } return FORCE_MOVE; } -void -UnstableTile::draw(DrawingContext& context) +void UnstableTile::shake (void) +{ + if (state != STATE_NORMAL) + return; + + if (sprite->has_action ("shake")) { + state = STATE_SHAKE; + this->set_action ("shake", /* loops = */ 1); + } + else { + dissolve (); + } +} + +void UnstableTile::dissolve (void) +{ + if ((state != STATE_NORMAL) && (state != STATE_SHAKE)) + return; + + if (sprite->has_action ("dissolve")) { + state = STATE_DISSOLVE; + this->set_action ("dissolve", /* loops = */ 1); + } + else { + slow_fall (); + } +} + +void UnstableTile::slow_fall (void) { - Vector pos = get_pos(); - // shacking - if(timer.get_timegone() > CRACKTIME) { - pos.x += systemRandom.rand(-3, 3); - } + /* Only enter slow-fall if neither shake nor dissolve is available. */ + if (state != STATE_NORMAL) { + this->fall_down (); + return; + } - sprite->draw(context, pos, LAYER_TILES); + if (sprite->has_action ("fall-down")) { + state = STATE_SLOWFALL; + this->set_action ("fall-down", /* loops = */ 1); + physic.set_gravity_modifier (.10); + physic.enable_gravity (true); + slowfall_timer = 0.5; /* Fall slowly for half a second. */ + } + else { + remove_me (); + } +} + +void UnstableTile::fall_down (void) +{ + if ((state != STATE_NORMAL) + && (state != STATE_SHAKE) + && (state != STATE_DISSOLVE) + && (state != STATE_SLOWFALL)) + return; + + if (sprite->has_action ("fall-down")) { + state = STATE_FALL; + this->set_action ("fall-down", /* loops = */ 1); + physic.set_gravity_modifier (.98); + physic.enable_gravity (true); + } + else { + remove_me (); + } } void UnstableTile::update(float elapsed_time) { - if(falling) { - movement = physic.get_movement(elapsed_time); - if(!Sector::current()->inside(bbox)) { - remove_me(); - return; - } - } else if(hit) { - if(timer.check()) { - falling = true; - physic.enable_gravity(true); - flags &= ~FLAG_SOLID; - timer.stop(); - } else if(!timer.started()) { - timer.start(FALLTIME); - } - } else { - timer.stop(); + switch (state) + { + case STATE_NORMAL: + break; + + case STATE_SHAKE: + if (sprite->animation_done()) + dissolve (); + break; + + case STATE_DISSOLVE: + if (sprite->animation_done()) { + /* dissolving is done. Set to non-solid. */ + set_group (COLGROUP_DISABLED); + fall_down (); + } + break; + + case STATE_SLOWFALL: + if (slowfall_timer >= elapsed_time) + slowfall_timer -= elapsed_time; + else /* Switch to normal falling procedure */ + fall_down (); + movement = physic.get_movement (elapsed_time); + break; + + case STATE_FALL: + if (sprite->animation_done()) + remove_me (); + else + movement = physic.get_movement (elapsed_time); + break; } - hit = false; } -IMPLEMENT_FACTORY(UnstableTile, "unstable_tile"); +/* EOF */