src/badguy/walking_badguy.cpp

   1 //  SuperTux - WalkingBadguy
   2 //  Copyright (C) 2006 Christoph Sommer <christoph.sommer@2006.expires.deltadevelopment.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 <math.h>
  18
  19 #include "badguy/walking_badguy.hpp"
  20
  21 #include "sprite/sprite.hpp"
  22
  23 WalkingBadguy::WalkingBadguy(const Vector& pos,
  24                              const std::string& sprite_name,
  25                              const std::string& walk_left_action,
  26                              const std::string& walk_right_action,
  27                              int layer) :
  28   BadGuy(pos, sprite_name, layer),
  29   walk_left_action(walk_left_action),
  30   walk_right_action(walk_right_action),
  31   walk_speed(80),
  32   max_drop_height(-1),
  33   turn_around_timer(),
  34   turn_around_counter()
  35 {
  36 }
  37
  38 WalkingBadguy::WalkingBadguy(const Vector& pos,
  39                              Direction direction,
  40                              const std::string& sprite_name,
  41                              const std::string& walk_left_action,
  42                              const std::string& walk_right_action,
  43                              int layer) :
  44   BadGuy(pos, direction, sprite_name, layer),
  45   walk_left_action(walk_left_action),
  46   walk_right_action(walk_right_action),
  47   walk_speed(80),
  48   max_drop_height(-1),
  49   turn_around_timer(),
  50   turn_around_counter()
  51 {
  52 }
  53
  54 WalkingBadguy::WalkingBadguy(const Reader& reader,
  55                              const std::string& sprite_name,
  56                              const std::string& walk_left_action,
  57                              const std::string& walk_right_action,
  58                              int layer) :
  59   BadGuy(reader, sprite_name, layer),
  60   walk_left_action(walk_left_action),
  61   walk_right_action(walk_right_action),
  62   walk_speed(80),
  63   max_drop_height(-1),
  64   turn_around_timer(),
  65   turn_around_counter()
  66 {
  67 }
  68
  69 void
  70 WalkingBadguy::initialize()
  71 {
  72   if(frozen)
  73     return;
  74   sprite->set_action(dir == LEFT ? walk_left_action : walk_right_action);
  75   bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
  76   physic.set_velocity_x(dir == LEFT ? -walk_speed : walk_speed);
  77   physic.set_acceleration_x (0.0);
  78 }
  79
  80 void
  81 WalkingBadguy::set_walk_speed (float ws)
  82 {
  83   walk_speed = fabs (ws);
  84   /* physic.set_velocity_x(dir == LEFT ? -walk_speed : walk_speed); */
  85 }
  86
  87 void
  88 WalkingBadguy::add_velocity (const Vector& velocity)
  89 {
  90   physic.set_velocity(physic.get_velocity() + velocity);
  91 }
  92
  93 void
  94 WalkingBadguy::active_update(float elapsed_time)
  95 {
  96   BadGuy::active_update(elapsed_time);
  97
  98   float abs_cur_walk_speed = fabs (physic.get_velocity_x ());
  99   if ((abs_cur_walk_speed > (walk_speed - 5.0))
 100       && (abs_cur_walk_speed < (walk_speed + 5.0)))
 101   {
 102     physic.set_velocity_x ((dir == LEFT) ? -walk_speed : +walk_speed);
 103     physic.set_acceleration_x (0.0);
 104   }
 105   /* acceleration == walk-speed => it will take one second to get from zero to full speed. */
 106   else if (abs_cur_walk_speed < walk_speed) {
 107     physic.set_acceleration_x ((dir == LEFT) ? -walk_speed : +walk_speed);
 108   }
 109   else if (abs_cur_walk_speed > walk_speed) {
 110     physic.set_acceleration_x ((dir == LEFT) ? +walk_speed : -walk_speed);
 111   }
 112
 113   if (max_drop_height > -1) {
 114     if (on_ground() && might_fall(max_drop_height+1))
 115     {
 116       turn_around();
 117     }
 118   }
 119 }
 120
 121 void
 122 WalkingBadguy::collision_solid(const CollisionHit& hit)
 123 {
 124
 125   update_on_ground_flag(hit);
 126
 127   if (hit.top) {
 128     if (physic.get_velocity_y() < 0) physic.set_velocity_y(0);
 129   }
 130   if (hit.bottom) {
 131     if (physic.get_velocity_y() > 0) physic.set_velocity_y(0);
 132   }
 133
 134   if ((hit.left && (hit.slope_normal.y == 0) && (dir == LEFT)) || (hit.right && (hit.slope_normal.y == 0) && (dir == RIGHT))) {
 135     turn_around();
 136   }
 137
 138 }
 139
 140 HitResponse
 141 WalkingBadguy::collision_badguy(BadGuy& , const CollisionHit& hit)
 142 {
 143
 144   if ((hit.left && (dir == LEFT)) || (hit.right && (dir == RIGHT))) {
 145     turn_around();
 146   }
 147
 148   return CONTINUE;
 149 }
 150
 151 void
 152 WalkingBadguy::turn_around()
 153 {
 154   if(frozen)
 155     return;
 156   dir = dir == LEFT ? RIGHT : LEFT;
 157   sprite->set_action(dir == LEFT ? walk_left_action : walk_right_action);
 158   physic.set_velocity_x(-physic.get_velocity_x());
 159   physic.set_acceleration_x (-physic.get_acceleration_x ());
 160
 161   // if we get dizzy, we fall off the screen
 162   if (turn_around_timer.started()) {
 163     if (turn_around_counter++ > 10) kill_fall();
 164   } else {
 165     turn_around_timer.start(1);
 166     turn_around_counter = 0;
 167   }
 168
 169 }
 170
 171 void
 172 WalkingBadguy::freeze()
 173 {
 174   BadGuy::freeze();
 175   physic.set_velocity_x(0);
 176 }
 177
 178 void
 179 WalkingBadguy::unfreeze()
 180 {
 181   BadGuy::unfreeze();
 182   WalkingBadguy::initialize();
 183 }
 184
 185 float
 186 WalkingBadguy::get_velocity_y() const
 187 {
 188   return physic.get_velocity_y();
 189 }
 190
 191 void
 192 WalkingBadguy::set_velocity_y(float vy)
 193 {
 194   physic.set_velocity_y(vy);
 195 }
 196
 197 /* EOF */