X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fobject%2Funstable_tile.cpp;h=50ba0c624f270c7e162db35de38108233cdc3f76;hb=9f40a73e89c17a2862a1213343589c19eff42199;hp=4db794b6e3838fa6ddce5eed3e1b62721a3fb14b;hpb=d62647592b4ccffa89794af6fa03faaced46999d;p=supertux.git diff --git a/src/object/unstable_tile.cpp b/src/object/unstable_tile.cpp index 4db794b6e..50ba0c624 100644 --- a/src/object/unstable_tile.cpp +++ b/src/object/unstable_tile.cpp @@ -1,99 +1,160 @@ -// $Id$ -// -// SuperTux -// Copyright (C) 2005 Matthias Braun +// 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 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // 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. -#include - -#include "unstable_tile.hpp" -#include "lisp/lisp.hpp" -#include "object_factory.hpp" -#include "player.hpp" -#include "sector.hpp" -#include "resources.hpp" -#include "sprite/sprite_manager.hpp" +// along with this program. If not, see . + +#include "object/unstable_tile.hpp" + +#include "object/explosion.hpp" +#include "object/player.hpp" #include "sprite/sprite.hpp" +#include "supertux/constants.hpp" +#include "supertux/object_factory.hpp" -static const float CRACKTIME = 0.3; -static const float FALLTIME = 0.8; +UnstableTile::UnstableTile(const Reader& lisp) : + MovingSprite(lisp, LAYER_TILES, COLGROUP_STATIC), + physic(), + state(STATE_NORMAL), + slowfall_timer() +{ + sprite->set_action("normal"); + physic.set_gravity_modifier (.98); + physic.enable_gravity (false); +} -UnstableTile::UnstableTile(const lisp::Lisp& lisp) - : hit(false), falling(false) +HitResponse +UnstableTile::collision(GameObject& other, const CollisionHit& ) { - lisp.get("x", bbox.p1.x); - lisp.get("y", bbox.p1.y); - bbox.set_size(32, 32); - sprite = sprite_manager->create("unstable_tile"); - flags |= FLAG_SOLID; - set_group(COLGROUP_STATIC); + 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; } -UnstableTile::~UnstableTile() +void UnstableTile::shake (void) { - delete sprite; + if (state != STATE_NORMAL) + return; + + if (sprite->has_action ("shake")) { + state = STATE_SHAKE; + this->set_action ("shake", /* loops = */ 1); + } + else { + dissolve (); + } } -HitResponse -UnstableTile::collision(GameObject& other, const CollisionHit& hitdata) +void UnstableTile::dissolve (void) { - if(hitdata.normal.y < 0.8) - return FORCE_MOVE; + if ((state != STATE_NORMAL) && (state != STATE_SHAKE)) + return; - Player* player = dynamic_cast (&other); - if(player) - hit = true; + if (sprite->has_action ("dissolve")) { + state = STATE_DISSOLVE; + this->set_action ("dissolve", /* loops = */ 1); + } + else { + slow_fall (); + } +} - return FORCE_MOVE; +void UnstableTile::slow_fall (void) +{ + /* Only enter slow-fall if neither shake nor dissolve is available. */ + if (state != STATE_NORMAL) { + this->fall_down (); + return; + } + + 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::draw(DrawingContext& context) +void UnstableTile::fall_down (void) { - Vector pos = get_pos(); - // shacking - if(timer.get_timegone() > CRACKTIME) { - pos.x += (rand() % 6) - 3; - } + if ((state != STATE_NORMAL) + && (state != STATE_SHAKE) + && (state != STATE_DISSOLVE) + && (state != STATE_SLOWFALL)) + return; - sprite->draw(context, pos, LAYER_TILES); + 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 */