src/object/ispy.cpp

   1 //  SuperTux - Ispy
   2 //  Copyright (C) 2007 Christoph Sommer <christoph.sommer@2007.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 "object/ispy.hpp"
  18
  19 #include "object/player.hpp"
  20 #include "object/tilemap.hpp"
  21 #include "sprite/sprite.hpp"
  22 #include "supertux/object_factory.hpp"
  23 #include "supertux/sector.hpp"
  24 #include "supertux/tile.hpp"
  25
  26 Ispy::Ispy(const Reader& reader) :
  27   MovingSprite(reader, "images/objects/ispy/ispy.sprite", LAYER_TILES+5, COLGROUP_DISABLED),
  28   state(ISPYSTATE_IDLE),
  29   script(),
  30   dir(AUTO)
  31 {
  32   // read script to execute
  33   reader.get("script", script);
  34
  35   // read direction to face in
  36   std::string dir_str;
  37   bool facing_down = false;
  38   reader.get("direction", dir_str);
  39   if( dir_str == "left" ) dir = LEFT;
  40   if( dir_str == "right" ) dir = RIGHT;
  41   reader.get("facing-down", facing_down);
  42   if (facing_down) dir = DOWN;
  43   if (dir == AUTO) log_warning << "Setting an Ispy's direction to AUTO is no good idea" << std::endl;
  44
  45   // set initial sprite action
  46   sprite->set_action((dir == DOWN) ? "idle-down" : ((dir == LEFT) ? "idle-left" : "idle-right"));
  47 }
  48
  49 HitResponse
  50 Ispy::collision(GameObject& , const CollisionHit& )
  51 {
  52   return ABORT_MOVE;
  53 }
  54
  55 bool
  56 Ispy::line_intersects_line(Vector line1_start, Vector line1_end, Vector line2_start, Vector line2_end) {
  57   // Adapted from Striker, (C) 1999 Joris van der Hoeven, GPL
  58
  59   float a1 = line1_start.x, b1 = line1_start.y, a2 = line1_end.x, b2 = line1_end.y;
  60   float c1 = line2_start.x, d1 = line2_start.y, c2 = line2_end.x, d2 = line2_end.y;
  61
  62   float num = (b2-b1)*(c2-c1) - (a2-a1)*(d2-d1);
  63   float den1 = (d2-b2)*(c1-c2) + (a2-c2)*(d1-d2);
  64   float den2 = (d2-b2)*(a1-a2) + (a2-c2)*(b1-b2);
  65
  66   // normalize to positive numerator
  67   if (num < 0) {
  68     num =- num;
  69     den1 =- den1;
  70     den2 =- den2;
  71   }
  72
  73   // numerator is zero -> Check for parallel or coinciding lines
  74   if (num == 0) {
  75     if ((b1-b2)*(c1-a2) != (a1-a2)*(d1-b2)) return false;
  76     if (a1 == a2) {
  77       std::swap(a1, b1);
  78       std::swap(a2, b2);
  79       std::swap(c1, d1);
  80       std::swap(c2, d2);
  81     }
  82     if (a1 > a2) std::swap(a1, a2);
  83     if (c1 > c2) std::swap(c1, c2);
  84     return ((a1 <= c2) && (a2 >= c1));
  85   }
  86
  87   // Standard check
  88   return (den1>=0) && (den1<=num) && (den2>=0) && (den2<=num);
  89
  90 }
  91
  92 bool
  93 Ispy::intersects_line(Rect r, Vector line_start, Vector line_end)
  94 {
  95   Vector p1 = r.p1;
  96   Vector p2 = Vector(r.p2.x, r.p1.y);
  97   Vector p3 = r.p2;
  98   Vector p4 = Vector(r.p1.x, r.p2.y);
  99   if (line_intersects_line(p1, p2, line_start, line_end)) return true;
 100   if (line_intersects_line(p2, p3, line_start, line_end)) return true;
 101   if (line_intersects_line(p3, p4, line_start, line_end)) return true;
 102   if (line_intersects_line(p4, p1, line_start, line_end)) return true;
 103   return false;
 104 }
 105
 106 bool
 107 Ispy::free_line_of_sight(Vector line_start, Vector line_end, const MovingObject* ignore_object)
 108 {
 109
 110   // check if no tile is in the way
 111   float lsx = std::min(line_start.x, line_end.x);
 112   float lex = std::max(line_start.x, line_end.x);
 113   float lsy = std::min(line_start.y, line_end.y);
 114   float ley = std::max(line_start.y, line_end.y);
 115   std::list<TileMap*> solid_tilemaps = Sector::current()->solid_tilemaps;
 116   for (float test_x = lsx; test_x <= lex; test_x += 16) {
 117     for (float test_y = lsy; test_y <= ley; test_y += 16) {
 118       for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
 119         TileMap* solids = *i;
 120         const Tile* tile = solids->get_tile_at(Vector(test_x, test_y));
 121         if(!tile) continue;
 122         // FIXME: check collision with slope tiles
 123         if((tile->getAttributes() & Tile::SOLID)) return false;
 124       }
 125     }
 126   }
 127
 128   // check if no object is in the way
 129   using namespace collision;
 130   Sector::MovingObjects& moving_objects = Sector::current()->moving_objects;
 131   for(Sector::MovingObjects::const_iterator i = moving_objects.begin();
 132       i != moving_objects.end(); ++i) {
 133     const MovingObject* moving_object = *i;
 134     if (moving_object == ignore_object) continue;
 135     if (!moving_object->is_valid()) continue;
 136     if ((moving_object->get_group() == COLGROUP_MOVING)
 137         || (moving_object->get_group() == COLGROUP_MOVING_STATIC)
 138         || (moving_object->get_group() == COLGROUP_STATIC)) {
 139       if(intersects_line(moving_object->get_bbox(), line_start, line_end)) return false;
 140     }
 141   }
 142
 143   return true;
 144 }
 145
 146 void
 147 Ispy::update(float )
 148 {
 149
 150   if (state == ISPYSTATE_IDLE) {
 151     // check if a player has been spotted
 152     bool playerSpotted = false;
 153     std::vector<Player*> players = Sector::current()->get_players();
 154     for (std::vector<Player*>::iterator playerIter = players.begin(); playerIter != players.end(); ++playerIter) {
 155       Player* player = *playerIter;
 156
 157       Vector eye = get_bbox().get_middle();
 158       if (dir == LEFT) eye = Vector(get_bbox().p1.x, get_bbox().get_middle().y);
 159       if (dir == RIGHT) eye = Vector(get_bbox().p2.x, get_bbox().get_middle().y);
 160       if (dir == UP) eye = Vector(get_bbox().get_middle().x, get_bbox().p1.y);
 161       if (dir == DOWN) eye = Vector(get_bbox().get_middle().x, get_bbox().p2.y);
 162
 163       // test for free line of sight to any of all four corners and the middle of a player's bounding box
 164       if (free_line_of_sight(eye, player->get_bbox().p1, player)) playerSpotted = true;
 165       if (free_line_of_sight(eye, Vector(player->get_bbox().p2.x, player->get_bbox().p1.y), player)) playerSpotted = true;
 166       if (free_line_of_sight(eye, player->get_bbox().p2, player)) playerSpotted = true;
 167       if (free_line_of_sight(eye, Vector(player->get_bbox().p1.x, player->get_bbox().p2.y), player)) playerSpotted = true;
 168       if (free_line_of_sight(eye, player->get_bbox().get_middle(), player)) playerSpotted = true;
 169     }
 170
 171     if (playerSpotted) {
 172       sprite->set_action((dir == DOWN) ? "alert-down" : ((dir == LEFT) ? "alert-left" : "alert-right"), 1);
 173       state = ISPYSTATE_ALERT;
 174
 175       std::istringstream stream(script);
 176       Sector::current()->run_script(stream, "Ispy");
 177     }
 178   }
 179   if (state == ISPYSTATE_ALERT) {
 180     if (sprite->animation_done()) {
 181       sprite->set_action((dir == DOWN) ? "hiding-down" : ((dir == LEFT) ? "hiding-left" : "hiding-right"), 1);
 182       state = ISPYSTATE_HIDING;
 183     }
 184   }
 185   if (state == ISPYSTATE_HIDING) {
 186     if (sprite->animation_done()) {
 187       sprite->set_action((dir == DOWN) ? "showing-down" : ((dir == LEFT) ? "showing-left" : "showing-right"), 1);
 188       state = ISPYSTATE_SHOWING;
 189     }
 190   }
 191   if (state == ISPYSTATE_SHOWING) {
 192     if (sprite->animation_done()) {
 193       sprite->set_action((dir == DOWN) ? "idle-down" : ((dir == LEFT) ? "idle-left" : "idle-right"));
 194       state = ISPYSTATE_IDLE;
 195     }
 196   }
 197 }
 198
 199 IMPLEMENT_FACTORY(Ispy, "ispy");
 200
 201 /* EOF */