/*
    explosion.cpp - explosion animation mover
    Copyright (C) 2006 Mark boyd
    
    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 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be fun to play,
    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, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include <SDL/SDL.h>

#include "etc.h"
#include "explosion.h"



struct gib
{
  int o_x,o_y;
  std::vector<std::pair<int,int> > pixels;
  float dx,dy;
};
    

Uint8 getalpha(SDL_Surface *bmp, int x, int y)
{
  Uint8 r,g,b,a;
  SDL_GetRGBA(getpixel(bmp,x,y), bmp->format, &r, &g, &b, &a);
 
  return a; 
}
    
    

explosion *explosion_pool::get_explosion(const std::string &name, SDL_Surface *start)
{
  const int MAX_VEL=11;
  const int FRAMES=20;  //todo: fixed frame numer has to be considered a bug, because it's not framerate-indepedent
  
  if (m_explosions.find(name)==m_explosions.end())
  {
    //create an explosion then
    std::vector<gib> gibs;
    
    for(int x=1; x<start->w; x+=2)
    {
      for(int y=1; y<start->h; y+=2)
      {
        if (getalpha(start,x,y) != SDL_ALPHA_TRANSPARENT && randint(3)==0)
        {
          gib g;
          g.o_x=x;g.o_y=y;
  
          g.dx=(1.0*g.o_x-start->w/2)*MAX_VEL/(start->w+start->h+1) + 3.5*(randu()-0.5);
          g.dy=(1.0*g.o_y-start->h/2)*MAX_VEL/(start->w+start->h+1) + 3.5*(randu()-0.5);
          
          gibs.push_back(g);
        }
      }
    }
    
    //Attach adjacent pixels to each gib
    for(int x=0; x<start->w; x++)
    {
      for(int y=0; y<start->h; y++)
      {
        if (getalpha(start,x,y) != SDL_ALPHA_TRANSPARENT)
        {
          int gx=x,gy=y;
          if (gx%2==0) gx+=randint(2)*2-1;
          if (gy%2==0) gy+=randint(2)*2-1;
          for(int i=0; i<gibs.size(); ++i)
            if (gibs[i].o_x==gx && gibs[i].o_y==gy) 
            {
              gibs[i].pixels.push_back(std::make_pair(x,y));  
            }
        } 
      }
    } 
    
    //Create the bitmaps!
    std::vector<SDL_Surface *> frames;
    for(int i=0; i<FRAMES; ++i)
    {
      SDL_Surface *frame=create_surface(start->w*5, start->h*5);
      int x_adj = (frame->w-start->w)/2;
      int y_adj = (frame->h-start->h)/2;

      SDL_LockSurface(frame);
      SDL_LockSurface(start);
      for(int gi=0; gi<gibs.size(); ++gi)
      {
        for (int p=0; p<gibs[gi].pixels.size(); ++p)
        {
          int dest_x=x_adj+gibs[gi].pixels[p].first+int(i*gibs[gi].dx);   //first=x, second=y
          int dest_y=y_adj+gibs[gi].pixels[p].second+int(i*gibs[gi].dy);
          
          if (0<=dest_x && dest_x<frame->w &&
              0<=dest_y && dest_y<frame->h)
          {
          
             Uint8 r,g,b,a;
             SDL_GetRGBA(getpixel(start, gibs[gi].pixels[p].first, gibs[gi].pixels[p].second), start->format, &r, &g, &b, &a);
             if (i>FRAMES/2)
             {
               a = (SDL_ALPHA_TRANSPARENT*(i-FRAMES/2) + a*(FRAMES-i))*2/FRAMES;
             }
            
            putpixel(frame, dest_x, dest_y, SDL_MapRGBA(frame->format, r, g, b, a));
          }
        }
      }
      SDL_UnlockSurface(start);
      SDL_UnlockSurface(frame);
      

      SDL_UpdateRect(frame, 0,0,0,0);
      frames.push_back(frame);
    }
    m_explosions[name]=frames;

  }

  return new explosion(&(m_explosions[name]));
}

explosion_pool::~explosion_pool()
{
  for (std::map<std::string, std::vector<SDL_Surface *> >::iterator i=m_explosions.begin(); i!=m_explosions.end(); ++i)
  {
    for (int j=0; j<i->second.size(); ++j)
    {
      SDL_FreeSurface(i->second[j]);
    }
  }
}

explosion::explosion(std::vector<SDL_Surface *> *frames)
{
  m_frames=frames;
  m_frame_index=0;
}

void explosion::do_stuff(float time_interval)
{
  m_frame_index++;
  if (m_frame_index >= m_frames->size())
  {
    m_frame_index=m_frames->size()-1;
    die();
  }
}

SDL_Surface *explosion::pic() const
{
  return (*m_frames)[m_frame_index];
}