/* Drawable Class Header */
 
/* Preprocessor Directives */
#ifndef DRAWABLE__H
#define DRAWABLE__H
 
/* Necessary Libraries */
#include <SDL/SDL.h>
#include <vector>
#include <string>
#include <iostream>
#include <cmath>
#include "frame.h"
#include "drawable.h"
 
/* Global Constants*/
const float BACKGROUND_SPEED = 50.0;
const float PLAYER_SPEED = 5.0;
const int WIDTH = 670;
const int HEIGHT = 303;
const float COLLISION_DISTANCE = 35;
const float MAX_DISTANCE = 250;
const int EXPLOSION_SPEED = 30;
const float DUCK_XSPEED = 30;
 
class Drawable {
   public:
      Drawable(float x, float y, float xs, float ys) :
         xCoordinate(x), yCoordinate(y), xSpeed(xs), ySpeed(ys) { }
 
      Drawable(const Drawable& s) :
         xCoordinate(s.xCoordinate), yCoordinate(s.yCoordinate),
         xSpeed(s.xSpeed), ySpeed(s.ySpeed) { }
 
      virtual ~Drawable() {}
 
/* Pure Virtual Functions */
      virtual void draw() = 0;
      virtual void update(Uint32 ticks) = 0;
      virtual void advanceFramesUp() = 0;
      virtual void advanceFramesDown() = 0;
      virtual void resetFrames() = 0; 
      virtual void setFrames(std::vector<Frame> *) = 0;
      virtual void shoot() = 0;
      virtual bool shooting() const = 0;
      virtual bool collision(float, float) const = 0;
      virtual bool isExploding() const = 0;
      virtual void cullBullets() = 0;
 
/* Non Virtual Functions */
      float getX() const { return xCoordinate; }
      float getY() const { return yCoordinate; }
      void setX(float x) { xCoordinate = x; }
      void setY(float y) { yCoordinate = y; }
      float getSpeedX() const { return xSpeed; }
      float getSpeedY() const { return ySpeed; }
      void setSpeedY(float s) { ySpeed = s; }
      void setSpeedX(float s) { xSpeed = s; }
      void incrSpeedX(float incr) { xSpeed += incr; }
      void incrSpeedY(float incr) { ySpeed += incr; }
      void decrSpeedX(float incr) { xSpeed -= incr; }
      void decrSpeedY(float incr) { ySpeed -= incr; }
      void dragSpeedX(float incr) { xSpeed *= incr; }
      void dragSpeedY(float incr) { ySpeed *= incr; }
   protected:
      float xCoordinate;
      float yCoordinate;
      float xSpeed;
      float ySpeed;
};
#endif

#include <vector>
#include <iostream>
#include "frame.h"
#include "drawable.h"
#include "bullet.h"
 
using std::vector;
 
class Duck : public Drawable 
{
   public:
      //Default Constructor
      Duck(float x, float y, float xs, float ys, Frame *f, int i)
          : Drawable(x, y, xs, ys), currentFrame(0), bulletFrame(f), shootDirection(i){ 
      //Destructor
      ~Duck() { }
 
/* Inline Functions */
      //getFrame function.  Returns member variable Frame frame         
      Frame* getFrame() const { return new Frame((*duckFrames)[currentFrame % duckFrames->size()]); }
      //setFrames function.  Sets duckFrames to passed frame vector pointer
      void setFrames(std::vector<Frame> *f) { duckFrames = f; }
      //getCurrentFrame function.  Returns the index of the current frame
      int getCurrentFrame() const { return currentFrame % duckFrames->size(); }   
      //isExploding: Returns false, Duck objects cannot be exploding and ducks
      bool isExploding() const { return false; }
      //shooting function.  Returns true if bullets vector is non-empty
      bool shooting() const { return bullets.size() > 0; }//(bullets.size() > 0); }
      //resetFrames function.  Resets currentFrame to 0
      void resetFrames() { currentFrame = 0; }
      /* Stub Defined Virtual Functions */
      void advanceFramesUp() {}
      void advanceFramesDown() {}
 
/* Implementation Defined Functions */
      //Shooting and collision functions
      void cullBullets();
      void shoot();
      float distance(float x1, float y1, float x2, float y2) const; 
      bool collision(float x, float y) const;
 
      //Drawing Functions
      void advanceFrame(Uint32 ticks);
      void update(Uint32 ticks);
      void draw();
 
   private:
      //Vector for duck frames of animation
      std::vector<Frame> *duckFrames;
      //Vector for current Frame of animation
      int currentFrame;
      //Frame pointer for bullet image
      Frame *bulletFrame;
      //Vector of bullets
      vector<Bullet> bullets;
      int shootDirection;
};
 
//IMPLEMENTATION OF DUCK.H
 
#include "duck.h"
 
//Draw Function:
//Draws player to screen, draws players active bullets
void Duck::draw()
{ 
}
 
void Duck::advanceFrame(Uint32 ticks) 
{
}
 
//Update function
//updates the duck's location along with the location of all active duck-bullets
void Duck::update(Uint32 ticks) 
{
}
 
//cullBullets function
//Erases bullets that have traveled too far
void Duck::cullBullets() 
{
}
 
//Shoot function
//Creates new bullets in the player::std::<Bullet>Vector
void Duck::shoot() 
{
}
 
//Collision function
//Checks for collisions between duck-bullets and a set of x,y coordinates
bool Duck::collision(float x, float y) const 
{  
}
 
//Distance function
//Finds the hypot distance between two sets of points
float Duck::distance(float x1, float y1, float x2, float y2) const 
{
}

#include <iostream>
#include "duck.h"
#include "player.h"
 
class SmartDuck : public Duck 
{
   public:
      SmartDuck(float x, float y, float xs, float ys, Frame *f, Drawable &p, /* SDL_Surface *screen ,*/ int i)
      : Duck(x, y, xs, ys, f, i), /*io(IOSingleton::getInstance(screen))*/ player(p), currentMode(NORMAL), initSpeedX(xs) { }
 
      void draw();
      void update(Uint32 ticks);
      enum MODE {NORMAL, TRAIL, PANIC};
 
   private:	
      //IOSingleton *io;
      Drawable & player;
      MODE currentMode;
      float initSpeedX;
};
 
//IMPLEMENTATION FOR SMARTDUCK.H
 
#include <cmath>
 
#include "smartDuck.h"
 
const float SAFE_DISTANCE = WIDTH / 2;
const float MIN_DUCK_XSPEED = -300;
const float MAX_DUCK_XSPEED = -200;
 
float distance(int x1, int y1, int x2, int y2) 
{
}
 
void SmartDuck::draw() 
{
}
 
void SmartDuck::update(Uint32 ticks) 
{ 
}

#include <vector>
#include <iostream>
#include "frame.h"
#include "drawable.h"
#include "bullet.h"
 
using std::vector;
 
class Player : public Drawable
{
   public:
      //Default constructor
      Player(float x, float y, float xs, float ys, Frame *f)
                 : Drawable(x, y, xs, ys), currentFrame(0), bulletFrame(f) {}
 
     //Destructor
      ~Player() { delete bulletFrame; }      
 
 /* Implementation defined functions */
      void draw();
      bool collision(float x, float y) const;
 
      float distance(float x1, float y1, float x2, float y2) const;
      void cullBullets();
      void shoot();
      void advanceFramesUp();
      void advanceFramesDown();     
 
/* Inline functions */
      //setFrames function.  Sets the vector object playerFrames to vector pointer parameter
      void setFrames(std::vector<Frame> *f) { playerFrames = f; }
      //getFrame function.  Returns the current frame object
      Frame* getFrame() const { return new Frame((*playerFrames)[currentFrame]); }
      //getCurrentFrame function.  Returns the index of the current frame
      int getCurrentFrame() const { return currentFrame; }
      //shooting function.  Returns true if there are bullets draw on the screen
      bool shooting() const { return(bullets.size() > 0); }
      //isExploding function.  Returns false, as players are not exploding
      bool isExploding() const { return false; }
      //Update function.  Updates the position of the player sprite
      void update(Uint32 ticks);
      //resetFrames function.  Resets currentFrame to 0
      void resetFrames() { currentFrame = 0; }
 
   private:
      std::vector<Frame> *playerFrames;
      int currentFrame;
      Frame *bulletFrame;
      vector<Bullet> bullets;
};
 
//IMPLEMENTATION OF PLAYER.H
#include "player.h"
//Update function
//updates the players location along with the location of all active player-bullets
void Player::update(Uint32 ticks) 
{
}
 
//cullBullets function
//Erases bullets that have traveled too far
void Player::cullBullets() 
{
}
 
//Draw Function:
//Draws player to screen, draws players active bullets
void Player::draw() 
{
}
 
//advanceFramesUp function, advances frames for movement in up direction
void Player::advanceFramesUp()
{  
}
 
//advanceFramesDown function, advances frames for movement in down direction
void Player::advanceFramesDown()
{
}
 
//Shoot function
//Creates new bullets in the player::std::<Bullet>Vector
void Player::shoot() 
{
}
 
//Distance function
//Finds the hypot distance between two sets of points
float Player::distance(float x1, float y1, float x2, float y2) const 
{
}
 
//Collision function
//Checks for collisions between player-bullets and duck objects
bool Player::collision(float x, float y) const 
{  
}

void GameManager::loadPlayer()
{
   player = new Player(50, HEIGHT / 2, 0, 0, new Frame(bulletSurface, screen, bulletSurface->w, bulletSurface->h, 0, 0));
   player->setFrames(playerFrames);
}
 
void GameManager::loadDucks() 
{
//Trivial code omitted
  Drawable pDuck
   pDuck = new SmartDuck(x, y, xs, ys, new Frame(missleSurface, screen, missleSurface->w, missleSurface->h, 0, 0), *player, /* screen ,*/ 1);
   pDuck->setFrames(duckFrames);
   ducks.push_back(pDuck);
   }
 
void GameManager::fragDucks()
{
   //Additional Code Omitted, line 225
    if (dynamic_cast<Player*>(player)->collision(duckX, duckY))
   //Additional Code omitted
}