src/badguy/kugelblitz.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/kugelblitz.hpp"
  18
  19 #include <math.h>
  20
  21 #include "math/random_generator.hpp"
  22 #include "object/camera.hpp"
  23 #include "object/player.hpp"
  24 #include "sprite/sprite.hpp"
  25 #include "supertux/object_factory.hpp"
  26 #include "supertux/sector.hpp"
  27 #include "util/reader.hpp"
  28
  29 #define  LIFETIME 5
  30 #define  MOVETIME 0.75
  31 #define  BASE_SPEED 200
  32 #define  RAND_SPEED 150
  33
  34 Kugelblitz::Kugelblitz(const Reader& reader) :
  35   BadGuy(reader, "images/creatures/kugelblitz/kugelblitz.sprite"),
  36   pos_groundhit(),
  37   groundhit_pos_set(false),
  38   dying(),
  39   movement_timer(),
  40   lifetime(),
  41   direction(),
  42   state()
  43 {
  44   reader.get("x", start_position.x);
  45   sprite->set_action("falling");
  46   physic.enable_gravity(false);
  47   countMe = false;
  48 }
  49
  50 void
  51 Kugelblitz::initialize()
  52 {
  53   physic.set_velocity_y(300);
  54   physic.set_velocity_x(-20); //fall a little to the left
  55   direction = 1;
  56   dying = false;
  57 }
  58
  59 void
  60 Kugelblitz::collision_solid(const CollisionHit& chit)
  61 {
  62   hit(chit);
  63 }
  64
  65 HitResponse
  66 Kugelblitz::collision_player(Player& player, const CollisionHit& )
  67 {
  68   if(player.is_invincible()) {
  69     explode();
  70     return ABORT_MOVE;
  71   }
  72   // hit from above?
  73   if(player.get_movement().y - get_movement().y > 0 && player.get_bbox().p2.y <
  74      (get_bbox().p1.y + get_bbox().p2.y) / 2) {
  75     // if it's not is it possible to squish us, then this will hurt
  76     if(!collision_squished(player))
  77       player.kill(false);
  78     explode();
  79     return FORCE_MOVE;
  80   }
  81   player.kill(false);
  82   explode();
  83   return FORCE_MOVE;
  84 }
  85
  86 HitResponse
  87 Kugelblitz::collision_badguy(BadGuy& other , const CollisionHit& chit)
  88 {
  89   //Let the Kugelblitz explode, too? The problem with that is that
  90   //two Kugelblitzes would cancel each other out on contact...
  91   other.kill_fall();
  92   return hit(chit);
  93 }
  94
  95 HitResponse
  96 Kugelblitz::hit(const CollisionHit& hit)
  97 {
  98   // hit floor?
  99   if(hit.bottom) {
 100     if (!groundhit_pos_set)
 101     {
 102       pos_groundhit = get_pos();
 103       groundhit_pos_set = true;
 104     }
 105     sprite->set_action("flying");
 106     physic.set_velocity_y(0);
 107     //Set random initial speed and direction
 108     direction = systemRandom.rand(2)? 1: -1;
 109     int speed = (BASE_SPEED + (systemRandom.rand(RAND_SPEED))) * direction;
 110     physic.set_velocity_x(speed);
 111     movement_timer.start(MOVETIME);
 112     lifetime.start(LIFETIME);
 113
 114   } else if(hit.top) { // bumped on roof
 115     physic.set_velocity_y(0);
 116   }
 117
 118   return CONTINUE;
 119 }
 120
 121 void
 122 Kugelblitz::active_update(float elapsed_time)
 123 {
 124   if (lifetime.check()) {
 125     explode();
 126   }
 127   else {
 128     if (groundhit_pos_set) {
 129       if (movement_timer.check()) {
 130         if (direction == 1) direction = -1; else direction = 1;
 131         int speed = (BASE_SPEED + (systemRandom.rand(RAND_SPEED))) * direction;
 132         physic.set_velocity_x(speed);
 133         movement_timer.start(MOVETIME);
 134       }
 135     }
 136     /*
 137       if (Sector::current()->solids->get_tile_at(get_pos())->getAttributes() == 16) {
 138       //HIT WATER
 139       Sector::current()->add_object(new Electrifier(75,1421,1.5));
 140       Sector::current()->add_object(new Electrifier(76,1422,1.5));
 141       explode();
 142       }
 143       if (Sector::current()->solids->get_tile_at(get_pos())->getAttributes() == 48) {
 144       //HIT ELECTRIFIED WATER
 145       explode();
 146       }
 147     */
 148   }
 149   BadGuy::active_update(elapsed_time);
 150 }
 151
 152 void
 153 Kugelblitz::kill_fall()
 154 {
 155 }
 156
 157 void
 158 Kugelblitz::explode()
 159 {
 160   if (!dying) {
 161     sprite->set_action("pop");
 162     lifetime.start(0.2f);
 163     dying = true;
 164   }
 165   else remove_me();
 166 }
 167
 168 void
 169 Kugelblitz::try_activate()
 170 {
 171   // Much smaller offscreen distances to pop out of nowhere and surprise Tux
 172   float X_OFFSCREEN_DISTANCE = 400;
 173   float Y_OFFSCREEN_DISTANCE = 600;
 174
 175   Player* player = get_nearest_player();
 176   if (!player) return;
 177   Vector dist = player->get_bbox().get_middle() - get_bbox().get_middle();
 178   if ((fabsf(dist.x) <= X_OFFSCREEN_DISTANCE) && (fabsf(dist.y) <= Y_OFFSCREEN_DISTANCE)) {
 179     set_state(STATE_ACTIVE);
 180     if (!is_initialized) {
 181
 182       // if starting direction was set to AUTO, this is our chance to re-orient the badguy
 183       if (start_dir == AUTO) {
 184         Player* player = get_nearest_player();
 185         if (player && (player->get_bbox().p1.x > get_bbox().p2.x)) {
 186           dir = RIGHT;
 187         } else {
 188           dir = LEFT;
 189         }
 190       }
 191
 192       initialize();
 193       is_initialized = true;
 194     }
 195     activate();
 196   }
 197 }
 198
 199 /* EOF */