src/object/particlesystem_interactive.cpp

   1 //  $Id: particlesystem.cpp 2470 2005-05-11 14:49:28Z wansti $
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2004 Matthias Braun <matze@braunis.de>
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 #include <config.h>
  20
  21 #include <iostream>
  22 #include <cmath>
  23
  24 #include "particlesystem_interactive.h"
  25 #include "video/drawing_context.h"
  26 #include "lisp/parser.h"
  27 #include "lisp/lisp.h"
  28 #include "lisp/writer.h"
  29 #include "resources.h"
  30 #include "main.h"
  31
  32 #include "tile.h"
  33 #include "tilemap.h"
  34 #include "math/aatriangle.h"
  35 #include "collision.h"
  36 #include "collision_hit.h"
  37 #include "object/camera.h"
  38 #include "object/rainsplash.h"
  39 #include "badguy/bomb.h"
  40
  41 //TODO: Dynamically create splashes at collision spots
  42 //      Find a way to make rain collide with objects like bonus blocks
  43 //      Add an option to set rain strength
  44 ParticleSystem_Interactive::ParticleSystem_Interactive()
  45 {
  46     virtual_width = SCREEN_WIDTH;
  47     virtual_height = SCREEN_HEIGHT;
  48     layer = LAYER_TILES;
  49 }
  50
  51 ParticleSystem_Interactive::~ParticleSystem_Interactive()
  52 {
  53     std::vector<Particle*>::iterator i;
  54     for(i = particles.begin(); i != particles.end(); ++i) {
  55         delete *i;
  56     }
  57 }
  58
  59 void ParticleSystem_Interactive::draw(DrawingContext& context)
  60 {
  61   context.push_transform();
  62
  63     std::vector<Particle*>::iterator i;
  64     for(i = particles.begin(); i != particles.end(); ++i) {
  65         Particle* particle = *i;
  66         context.draw_surface(particle->texture, particle->pos, layer);
  67     }
  68
  69     context.pop_transform();
  70 }
  71
  72 bool
  73 ParticleSystem_Interactive::collision(Particle* object, Vector movement)
  74 {
  75   TileMap* solids = Sector::current()->solids;
  76   // calculate rectangle where the object will move
  77   float x1, x2;
  78   float y1, y2;
  79   x1 = object->pos.x;
  80   x2 = x1 + 32 + movement.x;
  81   y1 = object->pos.y;
  82   y2 = y1 + 32 + movement.y;
  83
  84   // test with all tiles in this rectangle
  85   int starttilex = int(x1-1) / 32;
  86   int starttiley = int(y1-1) / 32;
  87   int max_x = int(x2+1);
  88   int max_y = int(y2+1);
  89
  90   CollisionHit temphit, hit;
  91   Rect dest = Rect(x1, y1, x2, y2);
  92   dest.move(movement);
  93   hit.time = -1; // represents an invalid value
  94   for(int x = starttilex; x*32 < max_x; ++x) {
  95     for(int y = starttiley; y*32 < max_y; ++y) {
  96       const Tile* tile = solids->get_tile(x, y);
  97       if(!tile)
  98         continue;
  99       // skip non-solid tiles
 100       if(!(tile->getAttributes() & Tile::SOLID))
 101         continue;
 102
 103       if(tile->getAttributes() & Tile::SLOPE) { // slope tile
 104         AATriangle triangle;
 105         Vector p1(x*32, y*32);
 106         Vector p2((x+1)*32, (y+1)*32);
 107         triangle = AATriangle(p1, p2, tile->getData());
 108
 109         if(Collision::rectangle_aatriangle(temphit, dest, movement,
 110               triangle)) {
 111           if(temphit.time > hit.time)
 112             hit = temphit;
 113         }
 114       } else { // normal rectangular tile
 115         Rect rect(x*32, y*32, (x+1)*32, (y+1)*32);
 116         if(Collision::rectangle_rectangle(temphit, dest,
 117               movement, rect)) {
 118           if(temphit.time > hit.time)
 119             hit = temphit;
 120         }
 121       }
 122     }
 123   }
 124
 125   // did we collide at all?
 126   if(hit.time < 0)
 127     return false; else return true;
 128 }
 129
 130 RainParticleSystem::RainParticleSystem()
 131 {
 132     rainimages[0] = new Surface(datadir+"/images/objects/particles/rain0.png", true);
 133     rainimages[1] = new Surface(datadir+"/images/objects/particles/rain1.png", true);
 134
 135     virtual_width = SCREEN_WIDTH * 2;
 136
 137     // create some random raindrops
 138     size_t raindropcount = size_t(virtual_width/6.0);
 139     for(size_t i=0; i<raindropcount; ++i) {
 140         RainParticle* particle = new RainParticle;
 141         particle->pos.x = rand() % int(virtual_width);
 142         particle->pos.y = rand() % int(virtual_height);
 143         int rainsize = rand() % 2;
 144         particle->texture = rainimages[rainsize];
 145         do {
 146             particle->speed = (rainsize+1)*45 + (float(rand()%10)*.4);
 147         } while(particle->speed < 1);
 148         particle->speed *= 10; // gravity
 149
 150         particles.push_back(particle);
 151     }
 152 }
 153
 154 void
 155 RainParticleSystem::parse(const lisp::Lisp& reader)
 156 {
 157   reader.get("layer", layer);
 158 }
 159
 160 void
 161 RainParticleSystem::write(lisp::Writer& writer)
 162 {
 163   writer.start_list("particles-rain");
 164   writer.write_int("layer", layer);
 165   writer.end_list("particles-rain");
 166 }
 167
 168 RainParticleSystem::~RainParticleSystem()
 169 {
 170   for(int i=0;i<2;++i)
 171     delete rainimages[i];
 172 }
 173
 174 void RainParticleSystem::update(float elapsed_time)
 175 {
 176     std::vector<Particle*>::iterator i;
 177     for(
 178         i = particles.begin(); i != particles.end(); ++i) {
 179         RainParticle* particle = (RainParticle*) *i;
 180         float movement = particle->speed * elapsed_time;
 181         float abs_x = Sector::current()->camera->get_translation().x;
 182         float abs_y = Sector::current()->camera->get_translation().y;
 183         particle->pos.y += movement;
 184         particle->pos.x -= movement;
 185         if ((particle->pos.y > SCREEN_HEIGHT + abs_y) || (collision(particle, Vector(-movement, movement)))) {
 186             //Create rainsplash
 187             if (particle->pos.y <= SCREEN_HEIGHT + abs_y){
 188               //TODO: Find out at which side of the tile the collision happens
 189               bool vertical = false;
 190               int splash_x, splash_y;
 191               if (vertical) {
 192                 splash_x = int(particle->pos.x) - (int(particle->pos.x) % 32) + 32;
 193                 splash_y = int(particle->pos.y);
 194               }
 195               else {
 196                 splash_x = int(particle->pos.x);
 197                 splash_y = int(particle->pos.y) - (int(particle->pos.y) % 32) + 32;
 198               }
 199               Sector::current()->add_object(new RainSplash(Vector(splash_x, splash_y),vertical));
 200             }
 201             int new_x = (rand() % int(virtual_width)) + int(abs_x);
 202             int new_y = 0;
 203             //FIXME: Don't move particles over solid tiles
 204             particle->pos.x = new_x;
 205             particle->pos.y = new_y;
 206         }
 207     }
 208 }
 209
 210 CometParticleSystem::CometParticleSystem()
 211 {
 212     cometimages[0] = new Surface(datadir+"/images/creatures/mr_bomb/exploding-left-0.png", true);
 213     cometimages[1] = new Surface(datadir+"/images/creatures/mr_bomb/exploding-left-0.png", true);
 214
 215     virtual_width = SCREEN_WIDTH * 2;
 216
 217     // create some random comets
 218     size_t cometcount = 2;
 219     for(size_t i=0; i<cometcount; ++i) {
 220         CometParticle* particle = new CometParticle;
 221         particle->pos.x = rand() % int(virtual_width);
 222         particle->pos.y = rand() % int(virtual_height);
 223         int cometsize = rand() % 2;
 224         particle->texture = cometimages[cometsize];
 225         do {
 226             particle->speed = (cometsize+1)*30 + (float(rand()%10)*.4);
 227         } while(particle->speed < 1);
 228         particle->speed *= 10; // gravity
 229
 230         particles.push_back(particle);
 231     }
 232 }
 233
 234 void
 235 CometParticleSystem::parse(const lisp::Lisp& reader)
 236 {
 237   reader.get("layer", layer);
 238 }
 239
 240 void
 241 CometParticleSystem::write(lisp::Writer& writer)
 242 {
 243   writer.start_list("particles-comets");
 244   writer.write_int("layer", layer);
 245   writer.end_list("particles-comets");
 246 }
 247
 248 CometParticleSystem::~CometParticleSystem()
 249 {
 250   for(int i=0;i<2;++i)
 251     delete cometimages[i];
 252 }
 253
 254 void CometParticleSystem::update(float elapsed_time)
 255 {
 256     std::vector<Particle*>::iterator i;
 257     for(
 258         i = particles.begin(); i != particles.end(); ++i) {
 259         CometParticle* particle = (CometParticle*) *i;
 260         float movement = particle->speed * elapsed_time;
 261         float abs_x = Sector::current()->camera->get_translation().x;
 262         float abs_y = Sector::current()->camera->get_translation().y;
 263         particle->pos.y += movement;
 264         particle->pos.x -= movement;
 265         if ((particle->pos.y > SCREEN_HEIGHT + abs_y) || (collision(particle, Vector(-movement, movement)))) {
 266             if (particle->pos.y <= SCREEN_HEIGHT + abs_y) {
 267               Sector::current()->add_object(new Bomb(particle->pos, LEFT));
 268             }
 269             int new_x = (rand() % int(virtual_width)) + int(abs_x);
 270             int new_y = 0;
 271             //FIXME: Don't move particles over solid tiles
 272             particle->pos.x = new_x;
 273             particle->pos.y = new_y;
 274         }
 275     }
 276 }