X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fbadguy%2Fdispenser.cpp;h=da9514b513f45339654634bb407ab16b5f775f6f;hb=11e150736b6db59bfaef039f72c0daa11572d402;hp=e9e45ec2e5d462b0928fe9867e055f743a975b5d;hpb=8def1b51aa9d94b719ce975b88cd58c936d7c06e;p=supertux.git diff --git a/src/badguy/dispenser.cpp b/src/badguy/dispenser.cpp index e9e45ec2e..da9514b51 100644 --- a/src/badguy/dispenser.cpp +++ b/src/badguy/dispenser.cpp @@ -1,63 +1,263 @@ -#include +// SuperTux +// Copyright (C) 2006 Matthias Braun +// +// 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, see . -#include "dispenser.h" -#include "badguy/bouncing_snowball.h" +#include "badguy/dispenser.hpp" -Dispenser::Dispenser(LispReader& reader) -{ - reader.read_float("x", start_position.x); - reader.read_float("y", start_position.y); - reader.read_float("cycle", cycle); - reader.read_string("badguy", badguy); - bbox.set_size(32, 32); - sprite = sprite_manager->create("snowball"); -} +#include "audio/sound_manager.hpp" +#include "math/random_generator.hpp" +#include "object/bullet.hpp" +#include "object/player.hpp" +#include "supertux/object_factory.hpp" +#include "supertux/sector.hpp" +#include "util/reader.hpp" -void -Dispenser::write(LispWriter& writer) +#include + +Dispenser::Dispenser(const Reader& reader) : + BadGuy(reader, "images/creatures/dispenser/dispenser.sprite"), + cycle(), + badguys(), + next_badguy(), + dispense_timer(), + autotarget(), + swivel(), + broken(), + random(), + type() { - writer.start_list("dispenser"); + set_colgroup_active(COLGROUP_MOVING_STATIC); + sound_manager->preload("sounds/squish.wav"); + reader.get("cycle", cycle); + reader.get("badguy", badguys); + random = false; // default + reader.get("random", random); + type = "dropper"; //default + reader.get("type", type); + next_badguy = 0; + autotarget = false; + swivel = false; + broken = false; - writer.write_float("x", get_pos().x); - writer.write_float("y", get_pos().y); - writer.write_float("cycle", cycle); - writer.write_string("badguy", badguy); + if (badguys.size() <= 0) + throw std::runtime_error("No badguys in dispenser."); + + if (type == "rocketlauncher") { + sprite->set_action(dir == LEFT ? "working-left" : "working-right"); + set_colgroup_active(COLGROUP_MOVING); //if this were COLGROUP_MOVING_STATIC MrRocket would explode on launch. + + if (start_dir == AUTO) { + autotarget = true; + } + } else if (type == "cannon") { + sprite->set_action("working"); + } else { + sprite->set_action("dropper"); + } - writer.end_list("dispenser"); + bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height()); + countMe = false; } void Dispenser::activate() { - dispense_timer.start(cycle, true); + if( broken ){ + return; + } + if( autotarget && !swivel ){ // auto cannon sprite might be wrong + Player* player = this->get_nearest_player(); + if( player ){ + dir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT; + sprite->set_action(dir == LEFT ? "working-left" : "working-right"); + } + } + dispense_timer.start(cycle, true); + launch_badguy(); +} + +void +Dispenser::deactivate() +{ + dispense_timer.stop(); } +//TODO: Add launching velocity to certain badguys bool -Dispenser::collision_squished(Player& player) +Dispenser::collision_squished(GameObject& object) { - remove_me(); - player.bounce(*this); + //Cannon launching MrRocket can be broken by jumping on it + //other dispensers are not that fragile. + if (broken || type != "rocketlauncher") { + return false; + } + + sprite->set_action(dir == LEFT ? "broken-left" : "broken-right"); + dispense_timer.start(0); + set_colgroup_active(COLGROUP_MOVING_STATIC); // Tux can stand on broken cannon. + Player* player = dynamic_cast(&object); + if (player){ + player->bounce(*this); + } + sound_manager->play("sounds/squish.wav", get_pos()); + broken = true; return true; } +HitResponse +Dispenser::collision(GameObject& other, const CollisionHit& hit) +{ + Player* player = dynamic_cast (&other); + if(player) { + // hit from above? + if (player->get_bbox().p2.y < (bbox.p1.y + 16)) { + collision_squished(*player); + return FORCE_MOVE; + } + if(frozen){ + unfreeze(); + } + return FORCE_MOVE; + } + + Bullet* bullet = dynamic_cast (&other); + if(bullet){ + return collision_bullet(*bullet, hit); + } + + return FORCE_MOVE; +} + void -Dispenser::active_action(float elapsed_time) +Dispenser::active_update(float ) { - if (dispense_timer.check()) { - Sector::current()->add_object(new BouncingSnowball(get_pos().x, get_pos().y)); - } + if (dispense_timer.check()) { + // auto always shoots in Tux's direction + if( autotarget ){ + if( sprite->animation_done()) { + sprite->set_action(dir == LEFT ? "working-left" : "working-right"); + swivel = false; + } + + Player* player = this->get_nearest_player(); + if( player && !swivel ){ + Direction targetdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT; + if( dir != targetdir ){ // no target: swivel cannon + swivel = true; + dir = targetdir; + sprite->set_action(dir == LEFT ? "swivel-left" : "swivel-right", 1); + } else { // tux in sight: shoot + launch_badguy(); + } + } + } else { + launch_badguy(); + } + } } -HitResponse -Dispenser::collision_solid(GameObject& , const CollisionHit& hit) +void +Dispenser::launch_badguy() { - if(fabsf(hit.normal.y) > .5) { // hit floor or roof? - physic.set_velocity_y(0); - } else { // hit right or left - dir = dir == LEFT ? RIGHT : LEFT; - sprite->set_action(dir == LEFT ? "left" : "right"); - physic.set_velocity_x(-physic.get_velocity_x()); + //FIXME: Does is_offscreen() work right here? + if (!is_offscreen()) { + Direction launchdir = dir; + if( !autotarget && start_dir == AUTO ){ + Player* player = this->get_nearest_player(); + if( player ){ + launchdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT; + } + } + + if (badguys.size() > 1) { + if (random) { + next_badguy = gameRandom.rand(badguys.size()); + } + else { + next_badguy++; + + if (next_badguy >= badguys.size()) + next_badguy = 0; + } + } + + std::string badguy = badguys[next_badguy]; + + if(badguy == "random") { + log_warning << "random is outdated; use a list of badguys to select from." << std::endl; + return; + } + + try { + GameObject *game_object; + MovingObject *moving_object; + Vector spawnpoint; + Rectf object_bbox; + + /* Need to allocate the badguy first to figure out its bounding box. */ + game_object = ObjectFactory::instance().create(badguy, get_pos(), launchdir); + if (game_object == NULL) + throw std::runtime_error("Creating " + badguy + " object failed."); + + moving_object = dynamic_cast (game_object); + if (moving_object == NULL) + throw std::runtime_error(badguy + " is not a moving object."); + + object_bbox = moving_object->get_bbox (); + + if (type == "dropper") { + spawnpoint = get_anchor_pos (get_bbox (), ANCHOR_BOTTOM); + spawnpoint.x -= 0.5 * object_bbox.get_width (); + } + else if ((type == "cannon") || (type == "rocketlauncher")) { + spawnpoint = get_pos (); /* top-left corner of the cannon */ + if (launchdir == LEFT) + spawnpoint.x -= object_bbox.get_width () + 1; + else + spawnpoint.x += get_bbox ().get_width () + 1; + } + + /* Now we set the real spawn position */ + moving_object->set_pos (spawnpoint); + + Sector::current()->add_object(moving_object); + } catch(std::exception& e) { + log_warning << "Error dispensing badguy: " << e.what() << std::endl; + return; + } } +} - return CONTINUE; +void +Dispenser::freeze() +{ + BadGuy::freeze(); + dispense_timer.stop(); +} + +void +Dispenser::unfreeze() +{ + BadGuy::unfreeze(); + activate(); } + +bool +Dispenser::is_freezable() const +{ + return true; +} + +/* EOF */