Scratch

//**************************************************************************************
//DG Games -> HALO v/s Counter Strike V1
//**************************************************************************************
//Programmer : Abhishek Hingnikar (Dark¥)
//Date:: 28th December 2010
//Uses DarkGDK by Microsoft and The Game Creators
//(c)2010 - DG games - All rights Reserved
//All code is understandable if you are human x)

#include "DarkGDK.h"
// To make camera
float CamX = 0 ;
float CamY = 0 ;
// This functions will interconvert Computer Coordinates to the Cartesian Coordinates
inline float Conv2CartX(float X)
{ return X-512;
}

inline float Conv2CartY(float Y)
{ return 383-Y;
}

inline float Conv2CompX(float X)
{    return X +512;
}
inline float Conv2CompY(float Y)
{    return 383 - Y;
}
//Waypoints of Map and Code

struct Waypoint{
int LevelOne;// Initial Level 
int LevelTwo;// Final Level
int Xpos;
int Ypos;
char Type[4];// Type= J - Jump , S - StairCase;
int Link[4];// Index of waypoint Linked to it 
int UsedLinks;//To tell how many Links outa 4 has been used
};

Waypoint MapPoints[100];
int No_of_MapPoints=0;//No of mappoints using in the map so that we dont go on cheaching for all the points

// NO LETS MAKE SOME GROUND WHERE WE CAN STAND //

class ground{
int X;// Center Coordinates in cartesian
int Y;// Center Coordinates in catresian system

float C; // The line constant .. that is the Y coordinate at X = 0 u can find this by mathematica
float slope; // thats the angle that line makes wiv X axis;
float Length ; // length of the sprite In pixels;

int ImageID;
int SpriteID;

public:
    // I space is a function that returns 1 if the point is touching ground or is on ground else returns 0;

    inline    int Ispace(float h,float k)
    { if(abs(h-X)<=(Length*cos(slope)/2))
        { if(abs(k-(h*tan(slope)+C))<10)
            { return 1;
            }
        }
      return 0;
    }

    //Update is function to print the whole thing on screen
    inline void update()
    { dbSprite(SpriteID,Conv2CompX(X-CamX),Conv2CompY(Y-CamY),ImageID);

    }

    // Load() this should be called to Load Map block as its relaiable (XD)
void    Load()
    {
        dbRotateSprite(SpriteID,slope);
    }
};


//Now we have got a Template "Sprite" and we can now make tons of sprites of Map from it
//but we keeping in rather safe haha. So just Sprite IDs , 4 - 104, are assigned . to map blocks with the image IDs aswell
ground Map[100];// This is map sprites
int No_of_Ground=0;//This will tell now many sprites are in use so we only refresh them

//Now Lets Come to Basic Programming Mehtadologies :D
//Our first basic class which looks like a wargame rathern then  a ground survilliance system
// Ladies and gentle man I present to you the Class Called weapon XD

class Weapon{
float Velocity,Angle,X,Y,Dmi,Range;
int MyID,ImageID,Ammo,Clips,Capacity,Iowner,SoundReloadID,SoundFireID;
public:
void fire(int,int,float);//Declared at the end
void threw();
void Pickup(int);
void reload()
{if(Clips>0)
    {    Ammo += Capacity;
        Clips--;
    }
}

int isrealoading()
{ return dbSoundPlaying(SoundReloadID);
}

int isfiring()
{ return dbSoundPlaying(SoundFireID);
}
};

Weapon Guns[52];

class charac{
public:
    float X;
    float Y;
    float Health;
    int Weapons[2];
    int chosen;
    int SpriteIdUp;
    int SpriteIdDown;
    float dir;
    int ColiX;
    int ColiY;
    char Team; // C - CounterStrike , H - Halo
    void Damage(float DMI)
    { Health -= DMI;
    }

    int ispace(int h,int k)
    { if(abs(h-X)<(ColiX/2)&&abs(k-Y)<(ColiY/2))
        { return 1;
        }
    else
        { return 0;
        }
    }

    // Functions for BOT and HUMAN are different but only for input
    // Humans take input by the Human() function
    // Bots Use AI() and War() and Movement() functions for input.

    float damageindex(int);
    void Update()
    {

    }
};

charac Players[16];//The players in game where 0 is the base player
int No_of_Players;

void Weapon::fire(int Xpos,int Ypos,float dir) 
{    float VelX= Velocity*cos(dir);
    float VelY = Velocity*sin(dir);
    int i = 1;
    while( i*Velocity < Range)
    {for(int k =0;k<No_of_Players;k++)
        { if(Players[k].ispace((Xpos+(VelX*i)),(Ypos+(VelY*i))))
                { Players[k].Damage(Dmi);
                  return;
                }
        }
      for(int k = 0; k < No_of_Ground;k++)
        { if(Map[k].Ispace((Xpos+(VelX*i)),(Xpos+(VelX*i))))
            { return;
            }
        }
      i++;

    }
    return;
}


void Weapon::threw()
{ Players[Iowner].Weapons[Players[Iowner].chosen] = -1;
  X = Players[Iowner].X + 30;
  Y = Players[Iowner].Y - 30;
  Iowner = -1;
}

void Weapon::Pickup(int ByMe)
{ Iowner = ByMe;
Guns[Players[Iowner].Weapons[Players[Iowner].chosen]].threw();
Players[Iowner].Weapons[Players[Iowner].chosen] = MyID;
}
// the main entry point for the application is this function
void DarkGDK ( void )
{    dbSyncOn   ( );
    dbSetDisplayMode ( 1024 , 768 , 32 );
    dbSetWindowOff();
    dbSyncRate ( 60 );
    dbDisableEscapeKey ( );
    dbLoadImage("back.PNG",1);
    // Map INITIALISATION!

    while ( LoopGDK ( ) )
    {      for(int i=0;i<No_of_Players;i++)
        { Players[i].Update();
        }
        for(int i=0;i<No_of_Ground;i++)
        { Map[i].update();
        }
        if ( dbEscapeKey ( ) )
        {    break;
        }
        
        dbSync ( );
    }
    return;
}