headshot

[asitoka]

can i use your code to help me learn c++ like ill edit it and see the effects

[aryo_k]

i don't wanna continue, so i say its completed
download here: http://www.powerbit.nl.tp/ and then click games. there you'll see it

headshot is  a fps in wich you just have to shoot down guys continous.
they give you 10 pts per guy. and 3 ammo.
for the ones who want to view the source, its include with the post

hi *brammie*,

i cant download the source code, can u upload it again??


thanks a lot

[*brammie*]

main.h:

Code

GeSHi (cpp):
 
#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <dinput.h>
#include <math.h>
#include <iostream>
#include <sstream>
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)
#define CUSTOMFVF	(D3DFVF_XYZ | D3DFVF_NORMAL)
#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "d3dx9.lib")
#pragma comment (lib, "dinput8.lib")
#pragma comment (lib, "dxguid.lib")
 
LPDIRECT3D9					d3d;
LPDIRECT3DDEVICE9			d3ddev;
LPDIRECT3DVERTEXBUFFER9		gunshot_buffer = NULL;
LPDIRECT3DTEXTURE9			texture_1;
LPDIRECTINPUT8				din;   
LPDIRECTINPUTDEVICE8		dinkeyboard;
LPDIRECTINPUTDEVICE8		dinmouse;
LPDIRECT3DTEXTURE9			loading;
LPDIRECT3DTEXTURE9			clean;
LPDIRECT3DTEXTURE9			sprite;
LPDIRECT3DTEXTURE9			sprite2;
LPDIRECT3DTEXTURE9			sprite3;
LPDIRECT3DTEXTURE9			hpbar;
LPDIRECT3DTEXTURE9			reload;
LPDIRECT3DTEXTURE9			gameover;
LPD3DXSPRITE				d3dspt;
LPD3DXFONT					font;
int							ui_num=0;
float						mouse_x=0;
float						mouse_y=0;
float						x=0;
float						y=128;
float						z=0;
float						camdir=0;
float						camang=0;
float						gundir=0;
float						gunang=0;
float						hp=100;
int							walked;
int							time=0;
int							totaltime=0;
int							ammo=100;
int							aim=-1;
int							score=0;
bool						shooting;
bool						shoot_animation;
 
class model
{
private:
	LPD3DXMESH			mesh;
	DWORD				numMaterials;
	D3DMATERIAL9*		material; 
	LPDIRECT3DTEXTURE9*	texture; 
	bool init;
public:
	void init_model(LPCTSTR filename)
	{
		LPD3DXBUFFER bufMaterial;
		if (FAILED( D3DXLoadMeshFromX(filename,D3DXMESH_SYSTEMMEM,
                  d3ddev,NULL,&bufMaterial,NULL,
                  &numMaterials,&mesh))) 
		{
			PostQuitMessage(0);
		}
		D3DXMATERIAL* tempMaterials = (D3DXMATERIAL*)bufMaterial->GetBufferPointer();
		material = new D3DMATERIAL9[numMaterials];
		texture = new LPDIRECT3DTEXTURE9[numMaterials];
		for(DWORD i = 0; i < numMaterials; i++) 
		{
			material[i] = tempMaterials[i].MatD3D;  
			material[i].Ambient = material[i].Diffuse; 
			if(FAILED(D3DXCreateTextureFromFile(d3ddev,
                                            tempMaterials[i].pTextureFilename,
                                            &texture[i])))
			texture[i] = NULL;   
 
		}
		init=1;
		return;
	}
	void draw_model()
	{
		if (!init) return;
		for(DWORD i = 0; i < numMaterials; i++)
		{
			d3ddev->SetMaterial(&material[i]); 
			if(texture[i] != NULL)  d3ddev->SetTexture(0, texture[i]);
			else					d3ddev->SetTexture(0, clean);
			mesh->DrawSubset(i);
		}
		return;
	}
	void Release()
	{
		mesh->Release();
		return;
	}
};
class camera
{
public:
	D3DXVECTOR3 cam_pos;
	D3DXVECTOR3 cam_lookat;
	D3DXVECTOR3 cam_up;
private:
	D3DXMATRIX  matView;   
	D3DXMATRIX  matProjection;
public:
	int			FoV;
	float		aspect;
	float		znear,zfar;
private:
	bool		init;
public:
	void		cam_init()
	{
		cam_pos.x=0;
		cam_pos.y=0;
		cam_pos.z=0;
		cam_lookat.x=0;
		cam_lookat.y=0;
		cam_lookat.z=-10;
		cam_up.x=0;
		cam_up.y=1;
		cam_up.z=0;
		FoV=45;
		aspect=4/3;
		znear=1.0f;
		zfar =4096.0f;
		init=true;
		return;
	}
	void		set_view()
	{
		if (!init) return; 
		D3DXMatrixLookAtLH(&matView,&cam_pos,&cam_lookat,&cam_up); 
		D3DXMatrixPerspectiveFovLH(&matProjection,D3DXToRadian(FoV),aspect,znear,zfar); 
		d3ddev->SetTransform(D3DTS_VIEW, &matView);
		d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection);
		return;
	}
};
 
 
model						guy_stand;
model						guy_dead;
model						guy_wanim1;
model						guy_wanim2;
model						guy_wanim3;
float						pos(float neg);
float						point_direction(float x1,float y1,float x2,float y2);
float						point_distance(float x1,float y1,float x2,float y2);
float						MIN(float a,float b,float c,float d,float e,float f);
float						MAX(float a,float b,float c,float d,float e,float f);
float						round(float x);
int							random(int max);
class guy
{
public:
	float x,y,z;
	float wdir;
	float hp;
	bool  killed;
private:
	bool  initt;
	float wanim_frame;
public:
	void init(float xx,float yy,float zz)
	{
		if (initt) return;
		x=xx;
		y=yy;
		z=zz;
		hp=100;
		initt=true;
		killed=false;
		wanim_frame=0;
	}
	void process(float enemyx,float enemyy)
	{
		wanim_frame+=0.1f;
		if (killed && random(480)<2) 
		{
			killed=false;
			x=(float)-256+random(512);
			z=(float)-256+random(512);
			hp=100;
		}
		if (point_distance(x,z,enemyx,enemyy)>  8 && !killed && totaltime++>480*5) 
		{
			wdir=point_direction(x,z,enemyx,enemyy);
			x+=cos(D3DXToRadian(wdir+90))*4;
			z-=sin(D3DXToRadian(wdir+90))*4;
			if (wanim_frame>=9.0f) wanim_frame=0.0f;
		}
		else
		{
			wanim_frame=10.0f;
		}
		D3DXMATRIX transform,rotate;
		D3DXMatrixRotationY(&rotate,D3DXToRadian(wdir+90));
		D3DXMatrixTranslation(&transform,x,y,z);
		d3ddev->SetTransform(D3DTS_WORLD,&(rotate*transform));
		if (wanim_frame>=4 && wanim_frame<10) wanim_frame=0.0f;
		if (hp<1 && !killed) 
		{
			killed=true;
			ammo+=3;
			score+=10;
			if (ammo>100) ammo=100;
		}
		if (!killed) switch ((int) floor(wanim_frame))
		{
			case 0:  guy_wanim1.draw_model(); break;
			case 1:  guy_wanim2.draw_model(); break;
			case 2:  guy_wanim3.draw_model(); break;
			case 3:  guy_wanim2.draw_model(); break;
			default: guy_stand.draw_model();  break;
		}
		else
		{
			guy_dead.draw_model();
		}
		D3DXMatrixIdentity(&rotate);
		D3DXMatrixIdentity(&transform);
		d3ddev->SetTransform(D3DTS_WORLD,&(rotate*transform));
		return;
	}
	void Release()
	{
		initt=false;
		killed=true;
	}
};
struct CUSTOMVERTEX 
{
	FLOAT X, Y, Z; 
	D3DVECTOR NORMAL; 
};
 
model						gun;
model						gun_shot;
model						terrain;
camera						iface;
guy							enemys[5];
 
void						initD3D(HWND hWnd,HINSTANCE hinst);  
void						render_frame(void);  
void						cleanD3D(void);   
void						init_graphics(void); 
void						init_light(void);
void						init_input(HINSTANCE hInstance, HWND hWnd);  
void						detect_keys(void);   
void						detect_mousepos(void);   
void						clean_input(void);
void						make_texture(LPDIRECT3DTEXTURE9 *pOut,LPCTSTR filename);
void						draw_texture(LPDIRECT3DTEXTURE9 texture, RECT* texcoords, int x, int y, int a);
void						render_loadscreen(float a,float b);
LRESULT CALLBACK			WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
 
 
Created by GeSHI 1.0.7.18

[*brammie*]

main.cpp:

Code

GeSHi (cpp):
// game name: "headshot"
// game project started: 02/13/2008
#include "main.h"
// © 2008 Bram Buurlage
// © 2008 PowerBit Productions
// controls:	AWSD move
//				Mouse aim
//				Left MB shoot
int WINAPI			WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
    HWND hWnd;
    WNDCLASSEX wc;
    ZeroMemory(&wc, sizeof(WNDCLASSEX));
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WindowProc;
    wc.hInstance = hInstance;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszClassName = "WindowClass";
    RegisterClassEx(&wc);
    hWnd = CreateWindowEx(NULL, "WindowClass", "HeadShot v1.0",WS_EX_TOPMOST | WS_POPUP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,NULL, NULL, hInstance, NULL);
    ShowWindow(hWnd, nCmdShow);
    initD3D(hWnd,hInstance);
    MSG msg;
    while(TRUE)
    {
        DWORD starting_point = GetTickCount();
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
                break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        render_frame();
        if(KEY_DOWN(VK_ESCAPE))
            PostMessage(hWnd, WM_DESTROY, 0, 0);
        while ((GetTickCount() - starting_point) < (1/60)*1000);
    }
    cleanD3D();
    return msg.wParam;
}
LRESULT CALLBACK	WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            {
                PostQuitMessage(0);
                return 0;
            } break;
    }
 
    return DefWindowProc (hWnd, message, wParam, lParam);
}
 
 
 
 
// and this is where everything finally begins
// phew....
void	initD3D(HWND hWnd, HINSTANCE hinst)
{
    d3d = Direct3DCreate9(D3D_SDK_VERSION);
    D3DPRESENT_PARAMETERS d3dpp;
 
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = FALSE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = hWnd;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferWidth = SCREEN_WIDTH;
    d3dpp.BackBufferHeight = SCREEN_HEIGHT;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
 
    d3d->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dpp,&d3ddev);
	D3DXCreateSprite(d3ddev,&d3dspt);
	D3DXCreateFont(d3ddev,12,0,700,1,0,DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,NONANTIALIASED_QUALITY,DEFAULT_PITCH || FF_DONTCARE,"Tahoma",&font);
    init_graphics();
	init_light();
	init_input(hinst,hWnd);
 
	d3ddev->SetRenderState(D3DRS_LIGHTING,TRUE);
	d3ddev->SetRenderState(D3DRS_ZENABLE,TRUE);
	d3ddev->SetRenderState(D3DRS_NORMALIZENORMALS,TRUE);
	d3ddev->SetRenderState(D3DRS_AMBIENT,D3DCOLOR_XRGB(128,128,128));
	iface.cam_init();
	iface.cam_lookat.z=-5.0f;
 
    return;
}
void	render_frame(void)
{
	detect_mousepos();
	detect_keys();
 
    d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
    d3ddev->BeginScene();
    d3ddev->SetFVF(CUSTOMFVF);
	d3ddev->ShowCursor(true);
	 static RECT textbox; 
	 SetRect(&textbox, 320-32,16,320+32,32);
	 static char strdraw[10];
     _itoa_s(score,strdraw,10);
	 font->DrawTextA(NULL,(LPCSTR)&strdraw,strlen((LPCSTR) &strdraw),&textbox,DT_RIGHT | DT_VCENTER,D3DCOLOR_ARGB(255, 255, 255, 255)); 
 
	 iface.cam_pos.x=x;
	 iface.cam_pos.y=y+sin(D3DXToRadian(walked*4))/50;
	 iface.cam_pos.z=z;
	 iface.cam_lookat.x=x+ cos(D3DXToRadian(camdir))*cos(D3DXToRadian(camang));
	 iface.cam_lookat.y=y+ sin(D3DXToRadian(camang));
	 iface.cam_lookat.z=z- sin(D3DXToRadian(camdir))*cos(D3DXToRadian(camang));
	 iface.set_view();
 
	 for (int i=0; i<5; i++)
	 {
		 enemys[i].process(x,z);
	 }
     D3DXMATRIX matmove;
	 D3DXMATRIX matroty,matrotx;
	 D3DXMATRIX trans;
	 static float yrot; yrot=D3DXToRadian(gundir+180);
	 D3DXMatrixRotationZ(&matrotx,D3DXToRadian(-gunang));
	 D3DXMatrixRotationY(&matroty,yrot);
     D3DXMatrixTranslation(&matmove,x-(cos(yrot)*64-sin(yrot)*32),y-24-sin(D3DXToRadian(gunang)),z+(sin(yrot)*64+cos(yrot)*32));
	 if (camdir>gundir) gundir+=(camdir-gundir)/8;
	 if (camdir<gundir) gundir-=(gundir-camdir)/8;
	 if (camang>gunang) gunang+=(camang-gunang)/8;
	 if (camang<gunang) gunang-=(gunang-camang)/8;
	 if (camang>85) camang=85;
	 if (camang<-85) camang=-85;
	 D3DXMatrixMultiply(&trans,&matrotx,&matroty);
	 D3DXMatrixMultiply(&trans,&trans,&matmove);
	 d3ddev->SetTransform(D3DTS_WORLD, &trans);
	 d3ddev->SetStreamSource(0,gunshot_buffer,0,sizeof(CUSTOMVERTEX));
	 time++;
	 if (time>5) time=0;
	 if (time==5 && ammo>0)
	 {
		 shoot_animation=!shoot_animation;
		 if (shoot_animation && shooting)
		 {
			 ammo--;
			 if (aim+1) enemys[aim].hp-=50;
		 }
	 }
	 if (shooting && shoot_animation && ammo>0)
	 {
		 gun_shot.draw_model();
		 d3ddev->DrawPrimitive(D3DPT_LINELIST,0,1);
	 }
	 else
	 {
		 gun.draw_model();
	 }
 
	 D3DXMatrixIdentity(&matrotx);
	 D3DXMatrixIdentity(&matroty);
	 D3DXMatrixIdentity(&matmove);
	 D3DXMatrixMultiply(&trans,&matrotx,&matroty);
	 D3DXMatrixMultiply(&trans,&trans,&matmove);
	 d3ddev->SetTransform(D3DTS_WORLD, &trans);
	 D3DXMatrixScaling(&trans,1,2,1);
	 d3ddev->SetTransform(D3DTS_WORLD, &trans);
	 terrain.draw_model();
	 d3dspt->Begin(D3DXSPRITE_ALPHABLEND);
	  RECT box,bar;
	  box.left=0;
	  box.top=0;
	  box.right=64;
	  box.bottom=32;
	  bar.left=0;
	  bar.top=32;
	  bar.right=(LONG) ((64.0f/100.0f)*ammo);
	  bar.bottom=64;
	  draw_texture(sprite,&box,16,16,255);
	  draw_texture(sprite,&bar,16,16,255);
	  // aim construction
	  aim=-1;
	  for (int i=0; i<5; i++)
	  {
		static float newrot=0; newrot=gundir-90;
		static float afw; afw=36-point_distance(x,z,enemys[i].x,enemys[i].z)/9;
		if (afw<1) afw=1;
		while (newrot>360) newrot-=360;
		while (newrot<0  ) newrot+=360;
		if (round(point_direction(x,z,enemys[i].x,enemys[i].z)/afw)==round(newrot/afw) && !enemys[i].killed) aim=i;
		if (point_distance(x,z,enemys[i].x,enemys[i].z)<16 && time>2) hp-=5;
	  }	
	  if (aim<0) draw_texture(sprite2,NULL,320-64,240-64,128);
	  else		 draw_texture(sprite3,NULL,320-64,240-64,128);
 
	  // hp construction
	  box.left=0;
	  box.top=0;
	  box.right=128;
	  box.bottom=16;
	  bar.left=0;
	  bar.top=16;
	  bar.right=(LONG) ((128.0f/100.0f)*hp);
	  bar.bottom=32;
	  draw_texture(hpbar,&box,320-64,480-32,128);
	  draw_texture(hpbar,&bar,320-64,480-32,128);
	  if (hp<0) 
	  {
		  draw_texture(gameover,NULL,320-128,240-64,255);
		  ammo=0;
	  }
	  if (shooting && shoot_animation && ammo==0 && hp>0)
	  {
		  draw_texture(reload,NULL,320-128,240-64,128);
	  }
	 d3dspt->End();
    d3ddev->EndScene();
    d3ddev->Present(NULL, NULL, NULL, NULL);
 
    return;
}
void	cleanD3D(void)
{
    d3ddev->Release();
    d3d->Release();
	gun.Release();
	gun_shot.Release();
	terrain.Release();
	for (int i=0; i<5; i++)
	{
		enemys[i].Release();
	}
	gunshot_buffer->Release();
	clean_input();
 
    return;
}
void	init_graphics(void)
{
	srand(GetTickCount());
	float step=1,steps=18;
 
	make_texture(&loading,"data/load.bmp");
	gun.init_model("data/gun.x");								render_loadscreen(step++,steps);
	gun_shot.init_model("data/gun_shot.x");						render_loadscreen(step++,steps);
	terrain.init_model("data/terrain_hill.x");					render_loadscreen(step++,steps);
	for (int idx=0; idx<5; idx++)								
	{
		enemys[idx].init(-256.0f+random(512),0.0f,-256.0f+random(512));
	}
																render_loadscreen(step++,steps);
	D3DXCreateTextureFromFile(d3ddev,"data/clean.bmp",&clean);	render_loadscreen(step++,steps);
	make_texture(&sprite  ,"data/ui1.bmp");						render_loadscreen(step++,steps);
	make_texture(&sprite2 ,"data/ui2.bmp");						render_loadscreen(step++,steps);
	make_texture(&sprite3 ,"data/ui3.bmp");						render_loadscreen(step++,steps);
	make_texture(&hpbar   ,"data/ui4.bmp");						render_loadscreen(step++,steps);
	make_texture(&reload  ,"data/ui5.bmp");						render_loadscreen(step++,steps);
	make_texture(&gameover,"data/ui6.bmp");						render_loadscreen(step++,steps);
	guy_stand.init_model("data/guy_stand.x");					render_loadscreen(step++,steps);
	guy_dead.init_model("data/guy_dead.x");						render_loadscreen(step++,steps);
	guy_wanim1.init_model("data/guy_wanim_1.x");				render_loadscreen(step++,steps);
	guy_wanim2.init_model("data/guy_wanim_2.x");				render_loadscreen(step++,steps);
	guy_wanim3.init_model("data/guy_wanim_3.x");				render_loadscreen(step++,steps);
	D3DVECTOR normal;
	normal.x=0;
	normal.y=1;
	normal.z=0;
 
	CUSTOMVERTEX gunshot[]=
	{
		{0,0,0,normal,},
		{-1024,0,0,normal,},
	};
	d3ddev->CreateVertexBuffer(2*sizeof(CUSTOMVERTEX),0,CUSTOMFVF,
		D3DPOOL_MANAGED,&gunshot_buffer,NULL);					render_loadscreen(step++,steps);
	VOID* pvoid;
	gunshot_buffer->Lock(0,0,(void**)&pvoid,0);
	memcpy(pvoid,gunshot,sizeof(gunshot));						render_loadscreen(step++,steps);
	gunshot_buffer->Unlock();
	loading->Release();
    return;
}
void	init_light(void)
{
    D3DLIGHT9 light;
    ZeroMemory(&light, sizeof(light));
 
    light.Type = D3DLIGHT_DIRECTIONAL;
    light.Diffuse.r = 1.0f;
    light.Diffuse.g = 1.0f;
    light.Diffuse.b = 1.0f;
    light.Diffuse.a = 1.0f;
 
    D3DVECTOR vecDirection = {-0.5f, -0.5f, 0.0f};
	light.Direction = vecDirection;
	light.Specular.r = 1.0f;
	light.Specular.g = 1.0f;
	light.Specular.b = 1.0f;
	light.Specular.a = 1.0f;
    d3ddev->SetLight(0, &light);
    d3ddev->LightEnable(0, TRUE);
 
    return;
}
void	init_input(HINSTANCE hInstance, HWND hWnd)
{
    DirectInput8Create(hInstance,DIRECTINPUT_VERSION,IID_IDirectInput8,(void**)&din,NULL);
    din->CreateDevice(GUID_SysKeyboard,&dinkeyboard,NULL);
	din->CreateDevice(GUID_SysMouse   ,&dinmouse   ,NULL);
 
    dinkeyboard->SetDataFormat(&c_dfDIKeyboard);
	dinmouse->	 SetDataFormat(&c_dfDIMouse	  );
 
    dinkeyboard->SetCooperativeLevel(hWnd,DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
	dinmouse->   SetCooperativeLevel(hWnd,DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
 
	dinmouse->Acquire();
    return;
}
void	detect_keys(void)
{
    static BYTE keystate[256];
    dinkeyboard->Acquire();
    dinkeyboard->GetDeviceState(256, (LPVOID)keystate);
	if (hp<0) return;
	   if(keystate[DIK_W] & 0x80)
	   {
		   x+= cos(D3DXToRadian((float)camdir))*4;
		   z-= sin(D3DXToRadian((float)camdir))*4;
		   walked++;
	   }
	   if(keystate[DIK_S] & 0x80)
	   {
		   x+= cos(D3DXToRadian((float)camdir+180))*4;
		   z-= sin(D3DXToRadian((float)camdir+180))*4;
		   walked++;
	   }
 
	   if(keystate[DIK_A] & 0x80)
	   {
		   x+= cos(D3DXToRadian((float)camdir-90))*4;
		   z-= sin(D3DXToRadian((float)camdir-90))*4;
		   walked++;
	   }
	   if(keystate[DIK_D] & 0x80)
	   {
		   x+= cos(D3DXToRadian((float)camdir+90))*4;
		   z-= sin(D3DXToRadian((float)camdir+90))*4;
		   walked++;
	   }
	   if (x>512) x=512;
	   if (x<-512) x=-512;
	   if (z>512) z=512;
	   if (z<-512) z=-512;
    return;
}
void	detect_mousepos(void)
{
    static DIMOUSESTATE mouse;
    dinmouse->Acquire();
    dinmouse->GetDeviceState(sizeof(DIMOUSESTATE), (LPVOID)&mouse);
    if(mouse.rgbButtons[0] & 0x80)
	{
		shooting=true;
	}
	else
	{
		shooting=false;
	}
	mouse_x=(float)mouse.lX;
	mouse_y=(float)mouse.lY;
	camdir+=mouse_x/16;
	camang-=mouse_y/16;
 
    return;
}
void	clean_input(void)
{
    dinkeyboard->Unacquire();
	dinmouse   ->Unacquire();
    din		   ->Release();
    return;
}
void	make_texture(LPDIRECT3DTEXTURE9 *pOut,LPCTSTR filename)
{
	D3DXCreateTextureFromFileEx(d3ddev,filename,D3DX_DEFAULT,D3DX_DEFAULT,
                            D3DX_DEFAULT,NULL,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,
                            D3DX_DEFAULT,D3DX_DEFAULT,D3DCOLOR_XRGB(255, 0, 255),
                            NULL,NULL,pOut);
	return;
}
void	draw_texture(LPDIRECT3DTEXTURE9 texture, RECT* texcoords, int x, int y, int alpha)
{
	D3DXVECTOR3 center(0.0f, 0.0f, 0.0f), position((float)x,(float)y, 0.0f);
    d3dspt->Draw(texture, texcoords, &center, &position, D3DCOLOR_ARGB(alpha, 255, 255, 255));
	return;
}
void	render_loadscreen(float a,float b)
{
	d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
    d3ddev->BeginScene();
	 d3dspt->Begin(D3DXSPRITE_ALPHABLEND);
 
	  RECT box,bar;
	  box.left=0;
	  box.top=0;
	  box.right=256;
	  box.bottom=256;
	  bar.left=256;
	  bar.top=0;
	  bar.right=(LONG) ((a/b)*256+256);
	  bar.bottom=256;
	  draw_texture(loading,&box,320-128,240-128,255);
	  draw_texture(loading,&bar,320-128,240-128,255);
 
	 d3dspt->End();
	d3ddev->EndScene();
	d3ddev->Present(NULL, NULL, NULL, NULL);
	return;
}
float	pos(float neg)
{
	if (neg<0) return neg*-1;
	else       return neg* 1;
}
float	point_direction(float x1,float y1,float x2,float y2)
{
	return D3DXToDegree(atan2(x2-x1,y2-y1))+180;
}
float	point_distance (float x1,float y1,float x2,float y2)
{
	return sqrt( (pow(x2-x1,2))+(pow(y2-y1,2)) );
}
float	MIN(float a,float b,float c,float d,float e,float f)
{
	if (a<=b && a<=c && a<=d && a<=e && a<=f) return a;
	if (b<=a && b<=c && b<=d && b<=e && b<=f) return b;
	if (c<=a && c<=b && c<=d && c<=e && c<=f) return c;
	if (d<=a && d<=c && d<=c && d<=e && d<=f) return d;
	if (e<=a && e<=c && e<=d && e<=d && e<=f) return e;
	if (f<=a && f<=b && f<=c && f<=d && f<=e) return f;
	return 0;
}
float	MAX(float a,float b,float c,float d,float e,float f)
{
	if (a>=b && a>=c && a>=d && a>=e && a>=f) return a;
	if (b>=a && b>=c && b>=d && b>=e && b>=f) return b;
	if (c>=a && c>=b && c>=d && c>=e && c>=f) return c;
	if (d>=a && d>=c && d>=c && d>=e && d>=f) return d;
	if (e>=a && e>=c && e>=d && e>=d && e>=f) return e;
	if (f>=a && f>=b && f>=c && f>=d && f>=e) return f;
	return 0;
}
float	round(float x)
{
	int y=(int) x;
	int z=(int) x+1;
	float d1=pos((float)z-x),d2=pos((float)y-x);
	if (d1>d2) return (float)y;
	else	   return (float)z;
}
int		random(int max)
{
	return rand()%(int)max;
}
 
Created by GeSHI 1.0.7.18

[*brammie*]

don't look at the chaos, it's one of my first projects

[aryo_k]

hi brammie,

i read the code and to be honest i cant understand anything    YET 

thanks for your reply

[*brammie*]

i don't even get it.. this is a good example that you always have to use COMMENTS in your code... after some time you just forgot how it exactly works.

[kccc]

No, you commented:
// and this is where everything finally begins
// phew....