Projects Using HGE

WapMap

kijanek6 — Wed, 13 Apr 2011 21:25:51 -0400

WapMap is an unofficial map editor for WAP32 engine based games, including:
:arrow: Claw
:arrow: Gruntz
:arrow: Get Medieval

Project website:
http://wapmap.kijedi.tk

Videos:

Screens:

Python hge

victorlin — Fri, 21 Aug 2009 10:04:56 -0400

Hi,

I am always wondering, if I can use hge with Python, that would be really wonderful. So I want to write a python binding for hge. I notice there is already a project that provide python binding for hge, but it is under EVIL GNU license, well.... that's useless, who want to write a game that's under the evil gnu license? At last, I don't think so. So I find some time to write it.

I use boost.python to port HGE to python, and its license is MIT, it is still under development, you can download the demo to see how can it do now:

http://python-hge.googlecode.com/files/t2.zip

If you are interesting in that project, welcome :P

My boot Project

Xapac — Mon, 07 Feb 2011 08:29:03 -0500

Hello.

My First Game in HGE.
http://file.qip.ru/file/vLpKuhZY/ship_3.html

Windows vs. Linux (game about penguins) I expect criticics

AlexuS — Tue, 01 Feb 2011 07:13:02 -0500

Hi to all. This is my first project, using Haaf's Game Engine 1.8.1. It is about shooting penguins, falling down from zeppelins. You cannot win this game, because it is endless fighting. So, I know it has ugly graphic and no sounds. But development experience was nice.

Here is the link for downloading game with source code. It is ZIP-file.
http://www.4shared.com/file/XjkH2EDM/Test_project.html

I'll be glad to see your comments.

Keys:
LEFT - turn gun left,
RIGHT - turn gun right
SPACE - shoot
ESC - exit

P.S. Forgive my English, because my own language is Russian. :)

[help]I'm programming a HGE based framework.

XadillaX — Thu, 25 Nov 2010 18:56:29 -0500

I'm thinking about my own framework called "XPoly Framework".

I think it will have a set of managers like InterfaceManager, MouseManager, FontManager and so on. And I will alse use Design Pattern like Singleton and ObjectFactory.

The demo resource is using Legend of Mir 2.

I'm a newbie, and I've written one. But it's really so poor, I given it up and rewrite one.

Who interested in my project can get touch with me.
My blog is http://www.x2studio.net and my email is xadillax@acmdiy.net

I will set up a Google Code Site if possible.

KeyJones: arcade game & keyboard trainer

Rsn152 — Tue, 09 Nov 2010 22:52:14 -0500

KeyJones: game is a dynamic and exciting keyboard trainer like arcade game.
Goal of the game, controlling a submarine to collect all the stars at the level, avoiding a collision with depth charges. To control the use letter keys.

http://rsngame.com/wp-content/uploads/2010/10/SetupKeyJones.exe
Translated by Google. :D

Lianliankan

XadillaX — Sun, 31 Oct 2010 05:46:35 -0400

A Lianliankan Game of QQ style.
click two same item to explode them. And they at most can have 3 edges.

Download

Source Code
And you can view details here.

Rune Twister

virious — Thu, 03 Jun 2010 00:21:08 -0400

I wanted to present trailer of our game called Rune Twister. It's a mix of tetris-like games and match-3 games. The starting point of our game was our earlier prototype Rotatris. Demo version will be available this month.
Link to the trailer: Rune Twister - First Trailer.

Your opinions are welcome :).

Colonization remake. Landfall 0.40 up for download!

suliman — Thu, 12 Aug 2010 23:36:45 -0400

Hi

Landfall is a project i returned to after working on some other stuff. Its a freewere remake of the classic strategy-game Colonization by Sid Meier.

Direct download (6MB, needs directX)
http://www.fileden.com/files/2007/9/26/1460259/landfall.rar

Forums and more info
http://epagames.freeforums.org/landfall-f3.html

Some screens

More screens
http://www.fileden.com/files/2007/9/26/1460259/screen1.jpg
http://www.fileden.com/files/2007/9/26/1460259/screen3.jpg
http://www.fileden.com/files/2007/9/26/1460259/screen4.jpg

Puzzle platformer (Download Available)

G-Factor — Thu, 08 Jul 2010 19:08:58 -0400

EDIT: Download available

http://dl.dropbox.com/u/9752697/Spectrum_Boy_Beta_v_1.0.rar

I coded the death system for my game today and posted it on another site. Since I've already got it on youtube I thought I'd share it here. I SHOULD have a fully playable demo within 5-6 weeks.

ALL art is placeholder programmer art :)

NEW VIDEO (same video as in my post below)

Youtube video

The video is really choppy, it's not like that in game.

Caelum a casual pachinko game

anpd — Wed, 31 Mar 2010 00:35:35 -0400

Game is available at http://www.apgames.se/caelum

Tatrin 2

Lisergishnu — Sun, 01 Aug 2010 08:12:26 -0400

]

Hello everyone:

I made some classic tetris clone while studing the HGE engine and now ill post it here if someone wants to play some.

The controls are simple, though the game is in Spanish it shouldnt be a problem to comprehend, and less to play. I have a current bug that the ? is supossed to take you to a credits scene, but it doesnt returns input...

It has even implemented a highscore system if you guys wanna try it out.

I will post the source code on request, so just ask it here.

Greetings!
Liser

DOWNLOAD

Astro catch

Ako — Fri, 25 Jun 2010 20:36:23 -0400

A game i made, the sprites are from spritelib gpl pack and opengameart.com, except the drops and the volume bars i made myself

The main purpose of the game is to collect drops and keep the volume of your song up while earning points. The game is not very good looking and it does not have many effects but please give me some feedback on how i did.

Note: please read the readme file in Music\soundtrack folder

here is the download link

https://sourceforge.net/projects/astrocatch/

EDIT:

Controls:

The ship follows the mouse pointer

when the volume bar is full press left mouse button to activate score booster.

SCREENSHOTS:

Top-Down shooter

tigrang — Fri, 04 Jun 2010 02:12:59 -0400

I'm taking a C++ class at school and this is for my final project. The code needs some cleaning up for sure but overall I'm pretty happy with it.

Here's my first HGE game :)

Link to source and bin: http://www.fileden.com/files/2009/6/23/2487063//Shooter.zip

Textures aren't made by me. Credit goes to the creators of these sprites (I'll link you once I find 'em again.)

Edit: Comments on the code would be really helpful and greatly appreciated.

Bombzone refueled

pacus — Mon, 02 Jul 2007 01:50:58 -0400

We are working on a second version of our bombzone.
Bombzone is a little bomberman (Atomic Bomberman) clone.

Here the first little screenshot of the tileset for the factory-theme

if you want to play the first version, visit www.bombzone.de

First playable game

Akkernight — Thu, 29 Jan 2009 16:20:10 -0500

Hello!
Well, here I'm posting my first playable game! :D
It's not done yet, but still, it's playable ;)
Oh and it's a Ping Pong clone...
That's about it xD
Oh and sorry for the bad upload, but I've got no name for it, so it's just called HGE_testing (I started it by only testing HGE xP)

CONTROLS:
W = Move up
S = Move down
Space = Start game

EDIT: Noticed now that the collision is BAD xD I'll get working on that...
EDIT: Uploaded to better server

http://www.megaupload.com/?d=BCAJZ3VT

Source code:

http://www.megaupload.com/?d=MMVL50CU

Space Rampage Prototype

valdirSalgueiro — Wed, 22 Apr 2009 21:46:46 -0400

Shoot the horde of aliens that are taking over earth, with this fast paced shooter.

DOWNLOAD: http://gp.leveldesign.com.br/spaceRampagePrototype.rar

Videos:

Controls:

Z -> Shoot
X -> Special
Directionals -> Move

To use the special you need the blue bar all filled. Fill it by killing aliens.

This is just a prototype, one level, no bosses, no ending, but still fun, i hope :) oh, the aliens and the ship are placeholder ( r-type ;) )

id like to hear opinions and also if it lagged for you in any moment.

the game was made with a modified version of HGE

thanks!

X-Jumper [puzzle platformer/2010]

iXy — Sat, 08 May 2010 20:27:48 -0400

X-Jumper is a puzzle platformer with unique gameplay. At every level you must collect all elements (cristals/coins/apples). After collecting every element run to Exit as fast as you can.

Screenshots

Trailer on YouTube

HGE FractalFlake v1.0 (new)

stbenge — Wed, 12 Dec 2007 23:50:47 -0500

Hi everyone,

I posted this same program weeks ago, but it has since disappeared from the boards. That's ok, since the previous version behaved strangely on some video cards.

This is a new snowflake generator for Windows. It is a complete rewrite and is based on an iterative fractal function. It produces fairly realistic snowflakes.

You will need DirectX v8.0 or above for this program to work. There are many options available, including support for different image resolutions. An extensive help file is also included.

The link:
http://www.caltel.com/~abenge/hgeFractalFlake1.zip

[EDIT] 03/18/08
The source (20k zip):
http://www.caltel.com/~abenge/hgeFFsource.zip

Just unzip the file and you're good to go!

Some example images:
http://www.caltel.com/~abenge/ff1b.jpg
http://www.caltel.com/~abenge/ff1a.jpg

Enjoy!

HGEGL all source code

djoker — Sun, 11 Apr 2010 14:36:31 -0400

hi ppl i see lots of requests about hge with opengl and i give a try i code this in 1 day not much to say work fine like HGE directx i release all sources but the demos are in delphi

http://www.box.net/shared/q822ihkpvq

Amazing Pyramids released!

Merkredy — Tue, 20 Apr 2010 10:29:15 -0400

Hello All,

I would like to introduce my first game on HGE - Amazing Pyramids.
It is a casual/indie word game...
http://www.wst.com.ua/amazingpyramids/

Features:

- Engaging storyline spanning 4 exotic locations
- 16 thematic levels and tons of exciting mini-games
- 2 game modes: Adventure and Classic
- Unique dictionary containing over 18,000 words
- Original Egyptian music and thematic sound effects
- Worldwide high scores table

Hope you will like it!
Also, please contact me at gamedev|at|wst.com.ua
if you are interested in game distribution.

--
Best regards,
Oleg Sereda
mailto:gamedev@wst.com.ua

delete~

m0refi4 — Mon, 26 Apr 2010 19:01:38 -0400

empty

Could anyone recommend an open source installer wizard ?

stef — Tue, 06 Apr 2010 09:58:39 -0400

Could anyone recommend an open source installer wizard for my game?

- Like the InstallShield Wizard that I see everytime i install a program? I notice Installshield is selling for $499 on download.com

Any tips on saving information on the player's PC?

stef — Tue, 06 Apr 2010 08:35:21 -0400

Hi

Could someone offer me some tips on saving information on the player's PC without the player being able to find it . something really simple would be better

I was thinking about trying to save something in the registry.
Is it possible to save information in the registery from hge?

Stev

Heli In Trouble(Up)

djoker — Mon, 29 Mar 2010 22:38:36 -0400

Hi folks .
this is my small game i code today with HGE 4 Delphi
right mouse start game
left mouse apply force on hely

new collide system by Rects and level
but this is just 1 demo you can modify the map whit http://tilemap.co.uk/zipfiles/mapwin1422.zip

http://www.box.net/shared/7gcpkgo8pe

Beat Hazard PC coming to Steam

ColdBeamGames — Tue, 23 Mar 2010 11:09:03 -0400

Hi all,

My games Beat Hazard uses HGE and is out on Steam in April! HGE rocks!

Cold Beam Games is proud to announce that the PC version of the eye bleeding music driven game Beat Hazard is coming to Steam in April!

About the game:

Welcome to a new experience in gameplay mechanics: Beat Hazard

Gameplay Powered by YOUR Music!

Experience your music collection like never before with this intense music driven arcade shooter. Each of your songs will have its own unique ebb and flow based on the music.

Power up your spaceship and watch as the music boosts your firepower. Unleash hell on the enemy ships when you max out with weapon pickups!

Beat Hazard seamlessly mixes the love of gaming and music. Together they become greater than the sum of their parts.

* Unique music driven gameplay
* Gameplay possibilities as vast as your music collection
* Can you last a whole album in Survival Mode?
* 25 Steam achievements
* Compete against friends on Steam leader boards
* Real time updates via the in game News System
* Take on the all new super boss ship
* Power up and unleash the deadly Beat Hazard weapon
* Rank up to an Elite rated pilot
* Includes a kicking rock album to get you started

XBLIG version Review: 9.5/10 www.GamerLimit.com - 'You would be hard-pressed to find a more addictive downloadable title'

Links and information:

Gameplay Video:

Website:
www.coldbeamgames.com

Cheers,
Steve
Cold Beam Games.

HGE 4 Delphi 2D Game Engine(up3)New Box2D Demos

djoker — Thu, 18 Mar 2010 13:09:57 -0400

Hi folks this is the project i'm working on about 6 months.

HGE 4 delphi is not just wrapped its a full 2d game engine mixed with 3d.

new Features ;
Speak system,ogg music,
file system:memory and files
Features:

Render: Direct3d,Batch,Render-targets
Tiles : Mappy Tiles,
Sound system : OpenAll(load from resorce) , mikmod and eSpeak system
Internet: DirectPlay,Sockets
Particles: Hge system,Irrlicht(style) and Papi.
Phys:Box2D and chipmunk,
Input:DirectInput and win api.
Shaders:load from FX files.
Sprites:HGE systems and delphix sprite engine.
Mesh:md2 animations and .x static.
Collision:PolyPoint,Pixel and simple body(point)
Path Find:Pixel find and points system;
Gui:Hge system and chain system
Steering Behaviours;
Load HDR(High dynamic range imaging) images.

Load md2,x,particles and textures from pack

http://www.box.net/shared/qapsasenzc

[code]
procedure InitSystem;cdecl; external HGEDLL;
procedure InitSystemonWindow(win:integer);cdecl; external HGEDLL;
procedure EndSystem;cdecl; external HGEDLL;
function InitRender:boolean;cdecl; external HGEDLL;
function StartRender:boolean;cdecl; external HGEDLL;
procedure SetSystemLog(const filename:pchar)cdecl; external HGEDLL;

procedure TakeSnapshot(const value:pchar);cdecl; external HGEDLL;
procedure TakeSnapshotToDir(const value:pchar);cdecl; external HGEDLL;

procedure SetWindowCaption(const value:pchar);cdecl; external HGEDLL;
procedure SetWindowMode(value:boolean);cdecl; external HGEDLL;
procedure EnableBassSound(value:boolean);cdecl; external HGEDLL;
procedure EnableZBuffer(value:boolean);cdecl; external HGEDLL;
procedure SetVZync(value:boolean);cdecl; external HGEDLL;
procedure EnableTextureFilter(value:boolean);cdecl; external HGEDLL;
procedure EnableMouseCursor(value:boolean);cdecl; external HGEDLL;
procedure SetFps(fps:integer);cdecl; external HGEDLL;
procedure SetScreenMode( width, height, bpp:integer);cdecl; external HGEDLL;

procedure SetFrameCallBack( value:hgeCallback);cdecl; external HGEDLL;
procedure SetRenderCallBack( value:hgeCallback);cdecl; external HGEDLL;
procedure SetFocusLostCallBack( value:hgeCallback);cdecl; external HGEDLL;
procedure SetFocusGainCallBack( value:hgeCallback);cdecl; external HGEDLL;
procedure SetGFXRestoreCallBack( value:hgeCallback);cdecl; external HGEDLL;

function Texture_LoadImage( const filename:pchar): HTEXTURE;cdecl; external HGEDLL;
function Texture_CreateFrom(pixels:pointer; width, height, depth, pitch:integer): HTEXTURE;cdecl; external HGEDLL;
function Texture_Create( width, height:integer): HTEXTURE;cdecl; external HGEDLL;
function Texture_Load( filename:pchar;colorkey:dword=0;bMipmap:boolean=true): HTEXTURE;cdecl; external HGEDLL;
function Texture_LoadHDR( const filename:pchar;alpha:single): HTEXTURE;cdecl; external HGEDLL;
procedure Texture_Free(tex:HTEXTURE);cdecl; external HGEDLL;
function Texture_GetWidth(tex:HTEXTURE;bOriginal:boolean=false):integer;cdecl; external HGEDLL;
function Texture_GetHeight(tex:HTEXTURE;bOriginal:boolean=false):integer;cdecl; external HGEDLL;
procedure Texture_SetMask(tex:HTEXTURE;ColorKey:DWORD);cdecl; external HGEDLL;

procedure Texture_Lock( tex:HTEXTURE);cdecl; external HGEDLL;
procedure Texture_LockEx( tex:HTEXTURE; left,top,width,height:integer);cdecl; external HGEDLL;
function Texture_LockRect(tex:HTEXTURE):LOCKEDRECT;cdecl; external HGEDLL;
function Texture_GetPixel(tex:HTEXTURE;x, y:integer):dword;cdecl; external HGEDLL;
procedure Texture_GetPixelEx(tex:HTEXTURE; x, y:integer;var r,g,b:integer);cdecl; external HGEDLL;
procedure Texture_SetPixel(tex:HTEXTURE;x, y:integer;color:integer);cdecl; external HGEDLL;
procedure Texture_Unlock( tex:HTEXTURE);cdecl; external HGEDLL;
function Texture_SetLockEx(tex:HTEXTURE; out pLockedRect: LOCKEDRECT; pRect: PRect):integer;cdecl; external HGEDLL;
procedure Texture_Copy(texsrc:HTEXTURE;left,top,width,height:integer;texdst:HTEXTURE; x, y:integer);cdecl; external HGEDLL;
function Texture_GetPixelLock(tex:HTEXTURE; x, y:integer):dword;cdecl; external HGEDLL;
procedure Texture_SetPixelLock(tex:HTEXTURE; x, y:integer;color:dword);cdecl; external HGEDLL;
procedure Texture_GetPixelRGB(tex:HTEXTURE; x, y:integer;var r,g,b:integer);cdecl; external HGEDLL;

procedure Texture_DXLock(tex:HTEXTURE;var buffer:LOCKEDRECT);cdecl; external HGEDLL;
procedure Texture_DXUnlock(tex:HTEXTURE);cdecl; external HGEDLL;
function Texture_DXGetPixel(tex:HTEXTURE; buffer:LOCKEDRECT;x,y:integer):dword;cdecl; external HGEDLL;
procedure Texture_DXSetPixel(tex:HTEXTURE; buffer:LOCKEDRECT;x,y:integer;pixel:dword);cdecl; external HGEDLL;

function Gfx_BeginScene(target:HTARGET=0):boolean;cdecl; external HGEDLL;
procedure Gfx_EndScene;cdecl; external HGEDLL;
procedure Gfx_Clear( color:DWORD);cdecl; external HGEDLL;
procedure Gfx_RenderLine(x1,y1,x2,y2:single;color:DWORD=$FFFFFFFF;z:single=0.5);cdecl; external HGEDLL;
procedure Gfx_RenderTriple(const triple:phgeTriple);cdecl; external HGEDLL;
procedure Gfx_RenderQuad(const quad:phgeQuad);cdecl; external HGEDLL;
procedure Gfx_RenderQuadUp(const quad:phgeQuad);cdecl; external HGEDLL;
procedure Gfx_RenderCircle(x,y,Radius:single;Segments:integer;color:DWORD);cdecl; external HGEDLL;

procedure Gfx_VLine(x,y1,y2:integer;color:DWORD=$FFFFFFFF);cdecl; external HGEDLL;
procedure Gfx_HLine(x1,x2,y:integer;color:DWORD=$FFFFFFFF);cdecl; external HGEDLL;
procedure Gfx_Rect(x1,y1,x2,y2:single;color:DWORD=$FFFFFFFF;fill:boolean=false);cdecl; external HGEDLL;
procedure Gfx_Line(x1,y1,x2,y2:single;color:DWORD=$FFFFFFFF);cdecl; external HGEDLL;
procedure Gfx_Plot(x,y:single;color:DWORD=$FFFFFFFF);cdecl; external HGEDLL;
procedure Gfx_Rectangle( x, y, w, h:single;color:DWORD=$FFFFFFFF;fill:boolean=false);cdecl; external HGEDLL;
procedure Gfx_Circle(x, y, r:single;color:DWORD=$FFFFFFFF;fill:boolean=false);cdecl; external HGEDLL;

procedure Gfx_Polygon(Points:pointer;NumPoints:integer;color:DWORD=$FFFFFFFF;fill:boolean=false);cdecl; external HGEDLL;
procedure Gfx_PolygonEx(Points:pointer;NumPoints:integer;x,y,angle:single;color:DWORD=$FFFFFFFF;fill:boolean=false);cdecl; external HGEDLL;

procedure Gfx_EnableZMode(mode:boolean);cdecl; external HGEDLL;

function Gfx_GetPixelLock( x, y:integer):dword;cdecl; external HGEDLL;
procedure Gfx_SetPixelLock(x, y:integer;color:dword);cdecl; external HGEDLL;

procedure Gfx_Begin2D;cdecl; external HGEDLL;
procedure Gfx_End2D;cdecl; external HGEDLL;
procedure Gfx_Begin3D;cdecl; external HGEDLL;
procedure Gfx_End3D;cdecl; external HGEDLL;
procedure Gfx_Flip;cdecl; external HGEDLL;

procedure Gfx_SetClipping( x:integer=0;y:integer=0;w:integer=0;h:integer=0);cdecl; external HGEDLL;
procedure Gfx_SetTransform(x:single=0;y:single=0;dx:single=0;dy:single=0;rot:single=0;hscale:single=0;vscale:single=0);cdecl; external HGEDLL;

procedure Light_SetAmbient(r,g,b:integer);cdecl; external HGEDLL;
procedure Light_SetEnable(value:boolean);cdecl; external HGEDLL;
procedure Light_SetSun(index:integer;enable:boolean;r,g,b,range:single);cdecl; external HGEDLL;
procedure Light_SetPoint(x,y,z:single;index:integer;enable:boolean;r,g,b, range,att:single);cdecl; external HGEDLL;
procedure Light_SetSpot(x,y,z,dx,dy,dz:single;index:integer;enable:boolean;r,g,b,range,att,Theta,Falloff,Phi:single);cdecl; external HGEDLL;

procedure Blt_Draw(Texture:HTEXTURE;x,y,z,width,height,hotX,hotY,rot,hscale,vscale:single;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_Stretch( Texture:HTEXTURE;x1,y1, x2, y2,z:single;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_Flip(Texture:HTEXTURE;x,y,z,width,height,hotX,hotY,rot,hscale,vscale:single;VFlip,HFlip:boolean;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_Src(Texture:HTEXTURE;x,y,z,width,height,hotX,hotY:single;src:Trect;rot,hscale,vscale:single;VFlip,HFlip:boolean;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_DestSrc(Texture:HTEXTURE;Dest,Src:Trect;z,width,height,Angle:single;VFlip,HFlip:boolean;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_SimpleCenter(Texture:HTEXTURE;x,y,z,we,h:single;color:dword;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_Simple(Texture:HTEXTURE;x,y,z,w,h:single;color:dword;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_DrawTexFloat(Texture:HTEXTURE;x,y,z,w,h,ox,oy,scaleFactor:single;color:dword;BlendMode:integer);cdecl; external HGEDLL;
procedure Blt_DrawIndex(Texture:HTEXTURE;x,y,z,w,h,tw,th,angle:single;frame:integer;VFlip,HFlip:boolean;color:DWORD;BlendMode:integer);cdecl; external HGEDLL;

function Timer_GetTime:single;cdecl; external HGEDLL;
function Timer_GetDelta:single;cdecl; external HGEDLL;
function Timer_GetFPS:integer;cdecl; external HGEDLL;

function XMesh_Load(filename:pchar):void;cdecl; external HGEDLL;
procedure XMesh_LoadTexture(Mesh:void;filename:pchar;index:integer=0);cdecl; external HGEDLL;
procedure XMesh_Free(Mesh:void);cdecl; external HGEDLL;
procedure XMesh_Draw(Mesh:void;x,y,z,rx,ry,rz,scx,scy,scz:single;blend:integer);cdecl; external HGEDLL;

function MDLMesh_Load(filename,texturename:pchar):void;cdecl; external HGEDLL;
procedure MDLMesh_Free(Mesh:void);cdecl; external HGEDLL;
procedure MDLMesh_Draw(Mesh:void;frame:integer;x,y,z,rx,ry,rz,scx,scy,scz:single;blend:integer);cdecl; external HGEDLL;

function PolysColide( AVector:pointer; ANum:integer;APosition:HVector;AVelociti:HVector;AAngle:single;
BVector:pointer; BNum:integer;BPosition:HVector;BVelociti:HVector;BAngle:single;
var OutNormal:hVector;dt:single):boolean;cdecl; external HGEDLL;

function Input_GetKeyState(key:integer):boolean;cdecl; external HGEDLL;
function Input_KeyDown(key:integer):boolean;cdecl; external HGEDLL;
function Input_KeyUp(key:integer):boolean;cdecl; external HGEDLL;
function Input_GetKeyName(key:integer):pchar;cdecl; external HGEDLL;
function Input_GetKey:integer;cdecl; external HGEDLL;
function Input_GetChar:integer;cdecl; external HGEDLL;
procedure Input_GetMousePos(var x,y:single);cdecl; external HGEDLL;
procedure Input_GetMousePosEx(var x,y:integer);
procedure Input_SetMousePos(x,y:single);cdecl; external HGEDLL;
function Input_GetMouseWheel():integer;cdecl; external HGEDLL;
function Input_IsMouseOver():boolean;cdecl; external HGEDLL;
function Input_GetEvent(var event:hInputEvent):boolean;cdecl; external HGEDLL;

function DXInput_Init(mouseExclusive:boolean ):boolean;cdecl;external HGEDLL;
function DXInput_Update():boolean;cdecl;external HGEDLL;
function DXInput_KeyPressed(Key:integer):boolean;cdecl;external HGEDLL;
function DXInput_KeyReleased(Key:integer):boolean;cdecl;external HGEDLL;
function DXInput_MousePressed(But:integer):boolean;cdecl;external HGEDLL;
function DXInput_MouseReleased(But:integer):boolean;cdecl;external HGEDLL;
function DXInput_MouseX:integer;cdecl;external HGEDLL;
function DXInput_MouseY:integer;cdecl;external HGEDLL;
function DXInput_MouseAbsX:integer;cdecl;external HGEDLL;
function DXInput_MouseAbsY:integer;cdecl;external HGEDLL;
function DXInput_MouseAbsWheel:integer;cdecl;external HGEDLL;
procedure DXInput_Free;cdecl;external HGEDLL;

procedure Ini_SetInt(const section; const name:pchar;value:integer)cdecl; external HGEDLL;
function Ini_GetInt(const section:pchar; const name:pchar;def_val:integer=0):integer;cdecl; external HGEDLL;
procedure Ini_SetFloat(const section:pchar; const name:pchar;value:single);cdecl; external HGEDLL;
function Ini_GetFloat(const section:pchar; const name:pchar; def_val:single=0):single;cdecl; external HGEDLL;
procedure Ini_SetString(const section:pchar; const name:pchar; const value:pchar);cdecl; external HGEDLL;
function Ini_GetString(const section:pchar; const name:pchar;def_val:pchar):pchar;cdecl; external HGEDLL;

procedure Random_Seed( seed:integer=0)cdecl; external HGEDLL;
function Random_Int( min, max:integer):integer;cdecl; external HGEDLL;
function Random_Float(min, max:single):single;cdecl; external HGEDLL;

function Resource_Load(const filename:pchar;var size:DWORD):pointer;cdecl; external HGEDLL;
procedure Resource_Free(res:pointer);cdecl; external HGEDLL;
function Resource_AttachPack(const filename:pchar; const password:pchar):boolean;cdecl; external HGEDLL;
procedure Resource_RemovePack(const filename:pchar);cdecl; external HGEDLL;
function Resource_MakePath(const filename:pchar):pchar;cdecl; external HGEDLL;
function Resource_EnumFiles(const wildcard:pchar):pchar;cdecl; external HGEDLL;
function Resource_EnumFolders(const wildcard:pchar):pchar;cdecl; external HGEDLL;

function Target_Create(width, height:integer;zbuffer:boolean):HTARGET;cdecl; external HGEDLL;
procedure Target_Free( target:HTARGET);cdecl; external HGEDLL;
function Target_GetTexture(target:HTARGET):HTEXTURE;cdecl; external HGEDLL;

//____________________________________________________________
function Spline_Create:void;cdecl; external HGEDLL;
procedure Spline_Free(JSpline:void);cdecl; external HGEDLL;
procedure Spline_Clear(JSpline:void);cdecl; external HGEDLL;
procedure Spline_Update(Spline:void)cdecl; external HGEDLL;
procedure Spline_Render(Spline:void;x,y:single; color, controlColor:dword);cdecl; external HGEDLL;
function Spline_CountPixels(Spline:void):integer;cdecl; external HGEDLL;
procedure Spline_AddControlPoint(Spline:void;x,y:single);cdecl; external HGEDLL;
procedure Spline_GetControlPoint(Spline:void;index:integer;var x,y:single);cdecl; external HGEDLL;
procedure Spline_GetPixel(Spline:void;index:integer;var x,y:single);cdecl; external HGEDLL;

//____________________________________________________________
procedure WorldInit;cdecl; external HGEDLL;
procedure WorldUpdate(st:single);cdecl; external HGEDLL;
procedure WorldRender;cdecl; external HGEDLL;

function BodyPol_CreateBox(x,y,w,h,mass:single):void;cdecl; external HGEDLL;
function BodyPol_Create(x,y,mass:single;axVertices:void;iNumVertices:integer):void;cdecl; external HGEDLL;
procedure BodyPol_Draw(body:void);cdecl; external HGEDLL;
procedure BodyPol_Update(body:void;dt:single);cdecl; external HGEDLL;
procedure BodyPol_AddImpulse(body:void;x,y,dt:single);cdecl; external HGEDLL;
procedure BodyPol_AddForce(body:void;x,y:single);cdecl; external HGEDLL;
procedure BodyPol_AddForceOnPoint(body:void;x,y,px,py:single);cdecl; external HGEDLL;
function BodyPol_Colide(bodyA,bodyB:void;dt:single):boolean;cdecl; external HGEDLL;
function BodyPol_GetMass(body:void):single;cdecl; external HGEDLL;
function BodyPol_GetPosition(body:void):hvector;cdecl; external HGEDLL;
procedure BodyPol_SetPosition(body:void;x,y:single);cdecl; external HGEDLL;
function BodyPol_GetLinVelocity(body:void):hvector;cdecl; external HGEDLL;
procedure BodyPol_SetOrientation(Body:void;v:single);cdecl; external HGEDLL;
procedure BodyPol_SetDensity(Body:void;v:single);cdecl; external HGEDLL;
//____________________________________________________________

function PolyPoint_Create:void;cdecl; external HGEDLL;
procedure PolyPoint_Free(Poly:void);cdecl; external HGEDLL;
procedure PolyPoint_Update(Poly:void);cdecl; external HGEDLL;
procedure PolyPoint_Draw(Poly:void;color:dword;fill:boolean);cdecl; external HGEDLL;
procedure PolyPoint_SetOrientation(Poly:void;angle:single);cdecl; external HGEDLL;
procedure PolyPoint_SetPosition(Poly:void;x,y:single);cdecl; external HGEDLL;
procedure PolyPoint_Scale(Poly:void;x,y:single);cdecl; external HGEDLL;
procedure PolyPoint_AddPoint(Poly:void;x,y:single);cdecl; external HGEDLL;
function PolyPoint_Colide(APoly:void;speedx1,speedy1:single;BPoly:void;speedx2,speedy2,dt:single):boolean;cdecl; external HGEDLL;
//____________________________________________________________
function Sprite_Create(tex:HTEXTURE;x,y,w,h:single):HSprite;cdecl; external HGEDLL;
function Sprite_CreateSprite(const sprcopy:HSprite):HSprite;cdecl; external HGEDLL;
procedure Sprite_Free(spr:HSprite);cdecl; external HGEDLL;
procedure Sprite_Render(spr:HSprite;x,y:single);cdecl; external HGEDLL;
procedure Sprite_RenderEx(spr:HSprite;x,y,rot,hscale, vscale:single);cdecl; external HGEDLL;
procedure Sprite_RenderStretch(spr:HSprite;x1,y1,x2,y2:single);cdecl; external HGEDLL;
procedure Sprite_Render4V(spr:HSprite;x0,y0,x1,y1,x2,y2,x3,y3:single);cdecl; external HGEDLL;
procedure Sprite_SetTexture(spr:HSprite;tex:HTEXTURE);cdecl; external HGEDLL;
procedure Sprite_SetTextureRect(spr:HSprite;x,y,w,h:single;adjSize:boolean=false);cdecl; external HGEDLL;
procedure Sprite_SetColor(spr:HSprite;col:DWORD);cdecl; external HGEDLL;
procedure Sprite_SetColorEx(spr:HSprite;col:DWORD; i:integer);cdecl; external HGEDLL;
procedure Sprite_SetZ(spr:HSprite;z:single;i:integer=-1);cdecl; external HGEDLL;
procedure Sprite_SetBlendMode(spr:HSprite;blend:integer);cdecl; external HGEDLL;
procedure Sprite_SetHotSpot(spr:HSprite;x,y:integer);cdecl; external HGEDLL;
procedure Sprite_SetFlip(spr:HSprite; bX,bY:boolean;bHotSpot:boolean);cdecl; external HGEDLL;
function Sprite_GetTexture(spr:HSprite):HTEXTURE;cdecl; external HGEDLL;
procedure Sprite_GetTextureRect(spr:HSprite;var x,y,w,h:single);cdecl; external HGEDLL;
function Sprite_GetColor(spr:HSprite;i:integer):dword;cdecl; external HGEDLL;
function Sprite_GetZ(spr:HSprite;i:integer):single;cdecl; external HGEDLL;
function Sprite_GetBlendMode(spr:HSprite):integer;cdecl; external HGEDLL;
procedure Sprite_GetHotSpot(spr:HSprite;var x,y:single);cdecl; external HGEDLL;
procedure Sprite_GetFlip(spr:HSprite;var bx,by:boolean);cdecl; external HGEDLL;
function Sprite_GetWidth(spr:HSprite):integer;cdecl; external HGEDLL;
function Sprite_GetHeight(spr:HSprite):integer;cdecl; external HGEDLL;
function Sprite_GetBoundingBox(spr:HSprite;x,y:single):hrect;cdecl; external HGEDLL;
function Sprite_GetBoundingBoxEx(spr:HSprite;x,y,rot,hscale,vscale:single):hrect;cdecl; external HGEDLL;

function Sprite_ColideWith(sprA:void;ax,ay:single;sprB:void;bx,by:single):boolean;cdecl; external HGEDLL;

//______________________________________________________________________________________________________
function Anim_Create(tex:HTEXTURE;nframes:integer;FPS:single;x,y,w,h:single): HAnim;cdecl; external HGEDLL;
function Anim_CreateAnim(HAnim :hanim):Hanim;cdecl; external HGEDLL;
procedure Anim_Render(HAnim :hanim;x,y:single);cdecl; external HGEDLL;
procedure Anim_RenderEx(HAnim :hanim;x,y,rot,hscale, vscale:single);cdecl; external HGEDLL;
procedure Anim_RenderStretch(HAnim :hanim;x1,y1,x2,y2:single);cdecl; external HGEDLL;
procedure Anim_Play(anim:HAnim );cdecl; external HGEDLL;
procedure Anim_Stop(anim:HAnim );cdecl; external HGEDLL;
procedure Anim_Resume(anim:HAnim );cdecl; external HGEDLL;
procedure Anim_Update(anim:HAnim ; fDeltaTime:single);cdecl; external HGEDLL;
function Anim_IsPlaying(anim:HAnim ):boolean;cdecl; external HGEDLL;
procedure Anim_SetTexture(anim:HAnim;tex: HTEXTURE );cdecl; external HGEDLL;
procedure Anim_SetTextureRect(anim:HAnim ;x1,y1,x2y2:single);cdecl; external HGEDLL;
procedure Anim_SetMode(anim:HAnim ;m:integer);cdecl; external HGEDLL;
procedure Anim_SetSpeed(anim:HAnim ;FPS:single);cdecl; external HGEDLL;
procedure Anim_SetFrame(anim:HAnim ;n:integer);cdecl; external HGEDLL;
procedure Anim_SetFrames(anim:HAnim ;n:integer);cdecl; external HGEDLL;
procedure Anim_SetZ(anim:HAnim;z:single;i:integer=-1);cdecl; external HGEDLL;
procedure Anim_SetBlendMode(anim:HAnim;blend:integer);cdecl; external HGEDLL;
procedure Anim_SetHotSpot(anim:HAnim;x,y:integer);cdecl; external HGEDLL;
function Anim_GetMode(anim:HAnim ):integer;cdecl; external HGEDLL;
function Anim_GetSpeed(anim:HAnim ):single;cdecl; external HGEDLL;
function Anim_GetFrame(anim:HAnim ):integer;cdecl; external HGEDLL;
function Anim_GetFrames(anim:HAnim ):integer;cdecl; external HGEDLL;

//______________________________________________________________________________________________________
function Distort_Create(cols, rows:integer):HMesh;cdecl; external HGEDLL;
function Distort_Copy(cmesh:HMesh):hmesh;cdecl; external HGEDLL;
procedure Distort_Free(Mesh:HMesh);cdecl; external HGEDLL;
procedure Distort_Render(Mesh:HMesh;x,y:single);cdecl; external HGEDLL;
procedure Distort_Clear(Mesh:HMesh;col:DWORD;z:single);cdecl; external HGEDLL;
procedure Distort_SetTexture(Mesh:HMesh;tex:DWORD);cdecl; external HGEDLL;
procedure Distort_SetTextureRect(Mesh:HMesh;x,y,w,h:single);cdecl; external HGEDLL;
procedure Distort_SetBlendMode(Mesh:HMesh;blend:integer);cdecl; external HGEDLL;
procedure Distort_SetZ(Mesh:HMesh;col,row:integer;z:single);cdecl; external HGEDLL;
procedure Distort_SetColor(Mesh:HMesh;col,row:integer;color:dword);cdecl; external HGEDLL;
procedure Distort_SetDisplacement(Mesh:HMesh;col:integer;row:integer;dx,dy:single;ref:integer=0);cdecl; external HGEDLL;
function Distor_GetTexture(Mesh:HMesh):HTEXTURE;cdecl; external HGEDLL;
procedure Distort_GetTextureRect(Mesh:HMesh;var x,y,w,h:single);cdecl; external HGEDLL;
function Distort_GetBlendMode(Mesh:HMesh):integer;cdecl; external HGEDLL;
function Distort_GetZ(Mesh:HMesh;col, row:integer):single;cdecl; external HGEDLL;
function Distort_GetColor(Mesh:HMesh;col, row:integer):DWORD;cdecl; external HGEDLL;
procedure Distort_GetDisplacement(Mesh:HMesh; col, row:integer;var dx,dy:single;ref:integer);cdecl; external HGEDLL;
function Distort_GetRows(Mesh:HMesh):integer;cdecl; external HGEDLL;
function Distort_GetCols(Mesh:HMesh):integer;cdecl; external HGEDLL;

//________________________________________________________________________________________________
function Font_Create(const filename:pchar;bMipmap:boolean=false):hfont;cdecl; external HGEDLL;
procedure Font_Free(Font:Hfont);cdecl; external HGEDLL;
procedure Font_Render(Font:Hfont;x,y:single;const texto:pchar;align:integer=0);cdecl; external HGEDLL;
procedure Font_printf(Font:Hfont;x,y:single;const format:pchar;align:integer=0);cdecl; external HGEDLL;
procedure Font_printfb(Font:Hfont;x,y,w,h:single;const format:pchar;align:integer=0);cdecl; external HGEDLL;
procedure Font_SetColor(Font:Hfont;col:dword);cdecl; external HGEDLL;
procedure Font_SetZ(Font:Hfont; z:single)cdecl; external HGEDLL;
procedure Font_SetBlendMode(Font:Hfont; blend:integer);cdecl; external HGEDLL;
procedure Font_SetScale(Font:Hfont;scale:single);cdecl; external HGEDLL;
procedure Font_SetProportion(Font:Hfont; prop:single);cdecl; external HGEDLL;
procedure Font_SetRotation(Font:Hfont; rot:single);cdecl; external HGEDLL;
procedure Font_SetTracking(Font:Hfont; tracking:single);cdecl; external HGEDLL;
procedure Font_SetSpacing(Font:Hfont; spacing:single);cdecl; external HGEDLL;
function Font_GetColor(Font:Hfont):dword;cdecl; external HGEDLL;
function Font_GetZ(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetBlendMode(Font:Hfont):integer;cdecl; external HGEDLL;
function Font_GetScale(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetProportion(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetRotation(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetTracking(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetSpacing(Font:Hfont):single;cdecl; external HGEDLL;
function Font_GetSprite(Font:Hfont; chr:char):HSprite;cdecl; external HGEDLL;
function Font_GetPreWidth(Font:Hfont;chr:char):integer;cdecl; external HGEDLL;
function Font_GetPostWidth(Font:Hfont; chr:char):integer;cdecl; external HGEDLL;
function Font_GetHeight(Font:Hfont):integer;cdecl; external HGEDLL;
function Font_GetStringWidth(Font:Hfont;const texto:pchar;bMultiline:boolean):single;cdecl; external HGEDLL;
//------------------------------------------------------------------------------------------------------
{procedure Guichain_Create;cdecl; external HGEDLL;
procedure Guichain_Update;cdecl; external HGEDLL;
procedure Guichain_Destroy;cdecl; external HGEDLL;
procedure Guichain_Render;cdecl; external HGEDLL;
}
//------------------------------------------------------------------------------------------------------

procedure Gui_Render;cdecl; external HGEDLL;
function Gui_Update( dt:single):integer;cdecl; external HGEDLL;
function Gui_GetFocus:integer;cdecl; external HGEDLL;
procedure Gui_SetFocus(ind:integer);cdecl; external HGEDLL;
procedure Gui_Enter;cdecl; external HGEDLL;
procedure Gui_Leave;cdecl; external HGEDLL;
procedure Gui_AddCtrl(GUIObject:void);cdecl; external HGEDLL;
function Gui_GetCtrl(index:integer):void;cdecl; external HGEDLL;
procedure Gui_DelCtrl(id:integer);cdecl; external HGEDLL;
procedure Gui_MoveCtrl(id:integer;x,y:single);cdecl; external HGEDLL;
procedure Gui_ShowCtrl(id:integer; bVisible:boolean);cdecl; external HGEDLL;
procedure Gui_EnableCtrl(id:integer; bVisible:boolean);cdecl; external HGEDLL;

function Gui_NewMenuItem(id:integer;fnt:HFont;x,y,delay:single;title:pchar):void;cdecl; external HGEDLL;
function Gui_MenuItemIsClick(Item:void):boolean;cdecl; external HGEDLL;

function Gui_NewText(id:integer;const caption:pchar;x,y,w,h:single;fnt:HFont):void;cdecl; external HGEDLL;
procedure Gui_TextSetCaption(GUIText:void;const caption:pchar);cdecl; external HGEDLL;
procedure Gui_TextSetMode(GUIText:void;align:integer);cdecl; external HGEDLL;

function Gui_NewButton(id:integer;x,y,w,h:single;tex:HTEXTURE;tx,ty:single):void;cdecl; external HGEDLL;
procedure Gui_ButtonSetMode(GUIButton:void; m:boolean);cdecl; external HGEDLL;
function Gui_ButtonIsPressed(GUIButton:void):boolean;cdecl; external HGEDLL;

function Gui_NewSlider(id:integer;x,y,w,h:single;tex:HTEXTURE;tx,ty,sw,sh:single;vertical:boolean=false):void;cdecl; external HGEDLL;
procedure Gui_SliderSeMode(GUISlider:void;fMin,fMax:single;mode:integer);cdecl; external HGEDLL;
procedure Gui_SliderSetValue(GUISlider:void;value:single);cdecl; external HGEDLL;
function Gui_SliderGetValue(GUISlider:void):single;cdecl; external HGEDLL;

function Gui_NewListBox(id:integer;x,y,w,h:single;fnt:HFont;tColor, thColor, hColor:DWORD):void;cdecl; external HGEDLL;
procedure Gui_ListBoxAddItem(GUIListbox:void;capt:pchar);cdecl; external HGEDLL;
procedure Gui_ListBoxDelItem(GUIListbox:void;item:integer);cdecl; external HGEDLL;
procedure Gui_ListBoxClear(GUIListbox:void);cdecl; external HGEDLL;
function Gui_ListBoxGetSelectedItem(GUIListbox:void):integer;cdecl; external HGEDLL;
procedure Gui_ListBoxSetSelectedItem(GUIListbox:void;index:integer);cdecl; external HGEDLL;

function Gui_NewMemo(id:integer;x,y,w,h:single;fnt:HFont;texto:pchar;color:DWORD= $FFFFFFFF):void;cdecl; external HGEDLL;
procedure Gui_MemoSetText(Element:void;text:pchar);cdecl; external HGEDLL;

function Gui_Edit(id:integer;x,y,w:single;fnt:HFont;str:pchar):void;cdecl; external HGEDLL;
procedure Gui_EditGetTex(Element:void; buffer:pchar;var len:integer);cdecl; external HGEDLL;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

function Particles_File(const filename:pchar; sprite:hsprite):HParticles;cdecl; external HGEDLL;
function Particles_Create(sprite:hsprite):HParticles;cdecl; external HGEDLL;
function Particles_Psi(psi:phParticleSystemInfo):void;cdecl; external HGEDLL;
function Particles_Ps(const ps:HParticles):HParticles;cdecl; external HGEDLL;

procedure Particles_Free(par:HParticles);cdecl; external HGEDLL;
procedure Particles_Render(par:HParticles);cdecl; external HGEDLL;
procedure Particles_FireAt(par:HParticles;x,y:single);cdecl; external HGEDLL;
procedure Particles_Fire(par:HParticles);cdecl; external HGEDLL;
procedure Particles_Stop(par:HParticles;bKillParticles:boolean);cdecl; external HGEDLL;
procedure Particles_Update(par:HParticles;fDeltaTime:single);cdecl; external HGEDLL;
procedure Particles_MoveTo(par:HParticles;x,y:single;bMoveParticles:boolean);cdecl; external HGEDLL;
procedure Particles_Transpose(par:HParticles;x,y:single);cdecl; external HGEDLL;
procedure Particles_SetScale(par:HParticles;scale:single);cdecl; external HGEDLL;
procedure Particles_TrackBoundingBox(par:HParticles;bTrack:boolean);cdecl; external HGEDLL;
function Particles_GetParticlesAlive(par:HParticles):boolean;cdecl; external HGEDLL;
function Particles_GetAge(par:HParticles):single;cdecl; external HGEDLL;
procedure Particles_GetPosition(par:HParticles;var x,y:single);cdecl; external HGEDLL;
procedure Particles_GetTransposition(par:HParticles;var x,y:single);cdecl; external HGEDLL;
function Particles_GetScale(par:HParticles):single;cdecl; external HGEDLL;
function Particles_GetBoundingBox(par:HParticles;inrect:HRect):hrect;cdecl; external HGEDLL;
procedure Particles_SetData(par:HParticles; psi:phParticleSystemInfo);cdecl; external HGEDLL;
procedure Particles_GetData(par:HParticles; psi:phParticleSystemInfo);cdecl; external HGEDLL;
procedure Particles_SetEmission(par:HParticles;value:integer );cdecl; external HGEDLL;
procedure Particles_SetSize (par:HParticles;SizeStart, SizeEnd:single );cdecl; external HGEDLL;
procedure Particles_SetColorStart (par:HParticles;r,g,b,a:single );cdecl; external HGEDLL;
procedure Particles_SetColorEnd (par:HParticles;r,g,b,a:single );cdecl; external HGEDLL;
procedure Particles_SetLifeTime(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;
procedure Particles_SetSpin(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;
procedure Particles_SetSpeed(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;
procedure Particles_SetGravity(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;
procedure Particles_SetDirection(par:HParticles;v:single );cdecl; external HGEDLL;
procedure Particles_SetSpread(par:HParticles;v:single );cdecl; external HGEDLL;
procedure Particles_SetRelative(par:HParticles;v:single );cdecl; external HGEDLL;
procedure Particles_SetRadialAccel(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;
procedure Particles_SetTangentialAccel(par:HParticles;lMin,lMax:single );cdecl; external HGEDLL;

//------------------------------------------------------------------------------------------------------

function ParticleManager_Create():HPManager;cdecl; external HGEDLL;
procedure ParticleManager_Free(par:HPManager);cdecl; external HGEDLL;
procedure ParticleManager_Update(par:HPManager;dt:single);cdecl; external HGEDLL;
procedure ParticleManager_Render(par:HPManager);cdecl; external HGEDLL;
function ParticleManager_SpawnPS(par:HPManager;psi:PHParticleSystemInfo;x, y:single):HParticles;cdecl; external HGEDLL;
function ParticleManager_IsPSAlive(par:HPManager;ps:HParticles):boolean;cdecl; external HGEDLL;
procedure ParticleManager_Transpose(par:HPManager;x,y:single);cdecl; external HGEDLL;
procedure ParticleManager_GetTransposition(par:HPManager;var dx,dy:single);cdecl; external HGEDLL;
procedure ParticleManager_KillPS(par:HPManager;ps:HParticles);cdecl; external HGEDLL;
procedure ParticleManager_KillAll(par:HPManager);cdecl; external HGEDLL;
//_____________________________________________________________________________________________________----
function Box2DWorld_Create( UpperX,UpperY, LowerX, LowerY, gravityX, gravityY:single;dosleep:boolean;debugDraw:boolean):HWorld;cdecl; external HGEDLL;
procedure Box2DWorld_Delete(World:HWorld)cdecl; external HGEDLL;
procedure Box2DWorld_Step (World:HWorld;timeStep:single;iterationCount:integer);cdecl; external HGEDLL;
procedure Box2DWorld_DebugFlags(flags:integer)cdecl; external HGEDLL;

function Box2DBody_CreateCircle(World:HWorld; x, y, angle, radius, density :single):HBody;cdecl; external HGEDLL;
function Box2DBody_CreateCircleEx(World:HWorld; x, y, angle, radius, density, Restitution, Friction :single):HBody;cdecl; external HGEDLL;
function Box2DBody_CreateBox(World:HWorld; x, y, angle, halfwidth, halfheight, density :single):HBody;cdecl; external HGEDLL;
function Box2DBody_CreateBoxEx(World:HWorld; x, y, angle, halfwidth, halfheight, density , Restitution, Friction :single):HBody;cdecl; external HGEDLL;
function Box2DBody_CreatePolygon(World:HWorld; x, y, angle, density :single;vertexCount:integer;verts:pointer):HBody;cdecl; external HGEDLL;
function Box2DBody_CreatePolygonEx(World:HWorld; x, y, angle, density,Restitution,Friction :single;vertexCount:integer;verts:pointer):HBody;cdecl; external HGEDLL;

procedure Box2DBody_Free(World:HWorld;Body:HBody);cdecl; external HGEDLL;
procedure Box2DBody_SetXForm(Body:HBody; x, y, angle :single);cdecl; external HGEDLL;
function Box2DBody_GetPosition(Body:HBody):hVector;cdecl; external HGEDLL;
function Box2DBody_GetAngle(Body:HBody):single;cdecl; external HGEDLL;

function Box2DBody_GetWorldVector(Body:HBody;x,y:single):hVector;cdecl; external HGEDLL;
function Box2DBody_GetWorldPoint(Body:HBody;x,y:single):hVector;cdecl; external HGEDLL;
function Box2DBody_GetLocalVector(Body:HBody;x,y:single):hVector;cdecl; external HGEDLL;
function Box2DBody_GetLocalPoint(Body:HBody;x,y:single):hVector;cdecl; external HGEDLL;

procedure Box2DBody_ApplyForce(Body:HBody; Forcex, Forcey, Pointx, Pointy :single);cdecl; external HGEDLL;
procedure Box2DBody_ApplyTorque(Body:HBody; torque :single);cdecl; external HGEDLL;
procedure Box2DBody_ApplyImpulse(Body:HBody; Impulsex, Impulsey, Pointx, Pointy :single);cdecl; external HGEDLL;

function Box2DJoint_DistanceCreate(World:HWorld;Body1,Body2:HBody;collideConnected:boolean=true):HJoint;cdecl; external HGEDLL;
function Box2DJoint_RevoluteCreate(World:HWorld;Body1,Body2:HBody;collideConnected:boolean=true):HJoint;cdecl; external HGEDLL;
function Box2DJoint_PulleyCreate (World:HWorld;
Body1,Body2:HBody;
anchor1 ,anchor2,
groundAnchor1 ,groundAnchor2:hvector;
r:single;
collideConnected:boolean =true):HJoint;cdecl; external HGEDLL;
//////////////////////////////////////////////////////////////////////////////////////
///////physics_chipmunk
procedure cp_CreateWorld(iterations :integer;x,y:single);cdecl; external HGEDLL;
procedure cp_Destroy;cdecl; external HGEDLL;
procedure cp_Update(dt:single);cdecl; external HGEDLL;
procedure cp_DebugDraw;cdecl; external HGEDLL;

procedure cp_AddStaticBoxShape(x,y,w,h,elasticity,friction:single;coltype:integer);cdecl; external HGEDLL;

function cp_CreateBoxBody(x,y,w,h,mass,elasticity,friction:single;coltype:integer):void;cdecl; external HGEDLL;
function cp_CreateBodyCircle(x,y,r,mass,elasticity,friction:single;coltype:integer):void;cdecl; external HGEDLL;
function cp_CreateStaticBodyBox(x,y,w,h,elasticity,friction:single;coltype:integer):void;cdecl; external HGEDLL;
function cp_CreateStaticBodyCircle(x,y,r,elasticity,friction:single;coltype:integer):void;cdecl; external HGEDLL;

function cp_GetBodyPosition(cpBody:void):hVector;cdecl; external HGEDLL;
function cp_GetBodyForce(cpBody:void):hVector;cdecl; external HGEDLL;
procedure cp_SetBodyPosition(cpBody:void;v:hVector);cdecl; external HGEDLL;
function cp_GetBodyRotation(cpBody:void):hVector;cdecl; external HGEDLL;
function cp_GetBodyAngle(cpBody:void):single;cdecl; external HGEDLL;
procedure cp_SetBodyAngle(cpBody:void;a:single);cdecl; external HGEDLL;
procedure cp_BodyApplyImpulse(cpBody:void;j,r:hVector);cdecl; external HGEDLL;
procedure cp_BodyApplyBiasImpulse(cpBody:void;j,r:hVector);cdecl; external HGEDLL;
procedure cp_BodyApplyForce(cpBody:void;j,r:hVector);cdecl; external HGEDLL;
procedure cp_BodyResetForce(cpBody:void);cdecl; external HGEDLL;
procedure cp_BodyUpdateVelocity(cpBody :void;gravity:hVector;damping, dt:single)cdecl; external HGEDLL;
procedure cp_BodyUpdatePosition(cpBody :void;dt:single);cdecl; external HGEDLL;

function cp_CountBodys:integer;cdecl; external HGEDLL;
function cp_GetBody(index:integer):void;cdecl; external HGEDLL;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
function Steer_Create:HSteer;cdecl;external HGEDLL;
procedure Steer_Destroy(Vehicle:HSteer);cdecl;external HGEDLL;

procedure Steer_Debug(Vehicle:HSteer);cdecl;external HGEDLL;
procedure Steer_SetMass(Vehicle:HSteer;mass:single);cdecl;external HGEDLL;
procedure Steer_SetSpeed(Vehicle:HSteer;speed:single);cdecl;external HGEDLL;
procedure Steer_SetRadius(Vehicle:HSteer;radius:single);cdecl;external HGEDLL;
procedure Steer_SetMaxForce(Vehicle:HSteer;mf:single);cdecl;external HGEDLL;
procedure Steer_SetMaxSpeed(Vehicle:HSteer;ms:single);cdecl;external HGEDLL;
procedure Steer_RandomizeHeading(Vehicle:HSteer);cdecl;external HGEDLL;

procedure Steer_UpdateProximity(Vehicle:HSteer);cdecl;external HGEDLL;
procedure Proximity_Create;cdecl;external HGEDLL;
procedure Proximity_Destroy;cdecl;external HGEDLL;
procedure Proximity_AddVehicle(Vehicle:HSteer);cdecl;external HGEDLL;

procedure Steer_ResetAcceleration(Vehicle:HSteer;x,y:single);cdecl;external HGEDLL;
function Steer_GetSpeed(Vehicle:HSteer):single;cdecl;external HGEDLL;

procedure Steer_ApplyForce(Vehicle:HSteer;x,y:single;time:single);cdecl;external HGEDLL;
procedure Steer_ApplyBrakingForce(Vehicle:HSteer;rate,time:single);cdecl;external HGEDLL;

procedure Steer_GetPosition(Vehicle:HSteer;var x,y:single);cdecl;external HGEDLL;
procedure Steer_SetPosition(Vehicle:HSteer;x,y:single);cdecl;external HGEDLL;

procedure Steer_FindNeighbors(Vehicle:HSteer;avg:HAVGroup;x,y,r:single);cdecl;external HGEDLL;

procedure Steer_SetWander(Vehicle:HSteer;dt:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetSeek(Vehicle:HSteer;x,y:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetFlee(Vehicle:HSteer;x,y:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetAvoidObstacle(Vehicle:HSteer;Obstacle:HObstacle;predictionTime:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetAvoidNeighbors(Vehicle:HSteer;vg:HAVGroup;minTimeToCollision:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetFollowPath(Vehicle:HSteer;Path:HPathway; direction:integer; predictionTime:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetEvasion(Vehicle1,Vehicle2:HSteer;maxPredictionTime:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetPursuit(Vehicle1,Vehicle2:HSteer;maxPredictionTime:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetAlignment(Vehicle:HSteer;vg:HAVGroup;maxDistance,cosMaxAngle:single;var rx,ry:single);cdecl cdecl;external HGEDLL;
procedure Steer_SetSeparation(Vehicle:HSteer;vg:HAVGroup;maxDistance,cosMaxAngle:single;var rx,ry:single);cdecl cdecl;external HGEDLL;

function PathLine_Create(pointCount:integer;Vects:pointer;radius:single; cyclic:boolean;debug:boolean=false):HPathway;cdecl;external HGEDLL;
procedure PathLine_Destroy(Path:HPathway);cdecl;external HGEDLL;

function Obstacle_AddSpherical(x,y,radius:single):HObstacle;cdecl;external HGEDLL;
procedure Obstacle_Delete(Obj:HObstacle);cdecl;external HGEDLL;

function Group_Create:HAVGroup;cdecl;external HGEDLL;
procedure Group_Destoy(vg:HAVGroup);cdecl;external HGEDLL;
procedure Group_AddVehicle(vg:HAVGroup;Vehicle:HSteer);cdecl;external HGEDLL;
procedure Group_RemoveVehicle(vg:HAVGroup;Vehicle:HSteer);cdecl;external HGEDLL;
procedure Group_Clear(vg:HAVGroup);cdecl;external HGEDLL;

procedure ObstacleGroup_Create(id:integer);cdecl;external HGEDLL;
procedure ObstacleGroup_Destroy(id :integer);cdecl;external HGEDLL;
procedure ObstacleGroup_AddObstacle( ObGroup:integer;obj:HObstacle);cdecl;external HGEDLL;
procedure ObstacleGroup_RemoveObstacle(ObGroup:integer;obj:HObstacle);cdecl;external HGEDLL;

//________________________________________________________________________________________________
function PathFind_Get (x,y:pointer):integer;cdecl;external HGEDLL;
function PathFind_Find (path:HMap; sx, sy, dx, dy:integer;options:integer=0):integer;cdecl;external HGEDLL;
function PathFind_Lenght:integer;cdecl;external HGEDLL;
procedure PathFind_Getindex(index:integer;var x,y:integer);cdecl;external HGEDLL;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

procedure Astar_Create(mem:integer=250);cdecl;external HGEDLL;
procedure Astar_Free;cdecl;external HGEDLL;
procedure Astar_SetNodeWayPoint(waypoint:hVector);cdecl;external HGEDLL;
function Astar_CalculatePath( startNode, endNode:integer):integer;cdecl;external HGEDLL;
function Astar_GetNode( waypoint:hVector):integer;cdecl;external HGEDLL;
function Astar_GetNearestNode(waypoint:hVector):integer;cdecl;external HGEDLL;
function Astar_GetFurthestNode(waypoint:hVector):integer;cdecl;external HGEDLL;
procedure Astar_SetAdjacentNode( node, value:integer);cdecl;external HGEDLL;
function Astar_GetWaypoint( index:integer):hVector;cdecl;external HGEDLL;
function Astar_GetDistFromWaypoint(index:integer;Pos:hVector):single;cdecl;external HGEDLL;
function Astar_GetRandomWaypoint():hVector;cdecl;external HGEDLL;
function Astar_GetNodeFromPath( index:integer):hVector;cdecl;external HGEDLL;
function Astar_PathSize:integer;cdecl;external HGEDLL;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
procedure Fader_Draw;cdecl;external HGEDLL;
procedure Fader_Update( timedelta:single)cdecl;external HGEDLL;
procedure Fader_In;cdecl;external HGEDLL;
procedure Fader_Out;cdecl;external HGEDLL;
function Fader_IsDone:boolean;cdecl;external HGEDLL;
procedure Fader_Color(r,g,b:single);cdecl;external HGEDLL;
procedure Fader_SetSpeed(value:integer);cdecl;external HGEDLL;
//_____________________________________________________________________________________________________

function Slider_Init( source, destination:HTexture;transition_type:TTransitionType; width, height:integer;duration:single = 1;offset_x:single = 0;offset_y:single = 0):void;cdecl;external HGEDLL;
procedure Slider_Free(Tr:void);cdecl;external HGEDLL;
procedure Slider_Update(Tr:void);cdecl;external HGEDLL;
procedure Slider_Draw(Tr:void;SourceDraw:boolean=true;DestinationDraw:boolean=true);cdecl;external HGEDLL;
function Slider_IsDone(Tr:void):boolean;cdecl;external HGEDLL;
function Slider_Steps(Tr:void):single;cdecl;external HGEDLL;

//_____________________________________________________________________________________________________

function Mth_Rand (num1,num2:single):single;cdecl;external HGEDLL;
function Mth_RandSeed (v:integer):boolean;cdecl;external HGEDLL;
function Mth_GetAngle (x1,y1,x2,y2:single):single;cdecl;external HGEDLL;
function Mth_GetDist (x1,y1,x2,y2:single):single;cdecl;external HGEDLL;
function Mth_NearAngle ( angle, dest, incr:single):single;cdecl;external HGEDLL;
function Mth_AdvanceX (Speed, Angle:single):single;cdecl;external HGEDLL;
function Mth_AdvanceY (Speed, Angle:single):single;cdecl;external HGEDLL;
//_____________________________________________________________________________________________________

function Mappy_Load(Filename:pchar;left , top , width , height:integer ):integer;cdecl;external HGEDLL;
procedure Mappy_Delete(Mappy:integer);cdecl;external HGEDLL;
function Mappy_DrawBG(Mappy:integer;depth:single;color:dword;blend:integer):boolean;cdecl;external HGEDLL;
function Mappy_DrawFG(Mappy:integer;depth:single;color:dword;blend:integer):boolean;cdecl;external HGEDLL;
procedure Mappy_DrawTile(Mappy:integer;tile:integer;x,y,w,h:single;color:dword);cdecl;external HGEDLL;
procedure Mappy_MoveTo(Mappy:integer; x, y:integer);cdecl;external HGEDLL;
procedure Mappy_InitAnims(Mappy:integer);cdecl;external HGEDLL;
procedure Mappy_UpdateAnims(Mappy:integer);cdecl;external HGEDLL;
procedure Mappy_SetBlockInPixels( Mappy, x, y, value:integer);cdecl;external HGEDLL;
procedure Mappy_SetBlock( Mappy, x, y, value:integer);cdecl;external HGEDLL;
procedure Mappy_GetBlock( Mappy, x, y:integer;var Block:BLKSTR);cdecl;external HGEDLL;
procedure Mappy_GetBlockInPixels( Mappy, x, y:integer;var Block:BLKSTR);cdecl;external HGEDLL;
procedure Mappy_GetPosition(Mappy:integer;var x,y);cdecl;external HGEDLL;
function Mappy_GetBlockBG( Mappy, x, y:integer):integer;cdecl;external HGEDLL;
function Mappy_GetBlockFG( Mappy, x, y:integer):integer;cdecl;external HGEDLL;
function Mappy_GetBlockID( blid, usernum:integer):integer;cdecl;external HGEDLL;
function Mappy_GetTile( Mappy, x , y :integer):integer;cdecl;external HGEDLL;
function Mappy_GetMatWidth(Mappy:integer):integer;cdecl;external HGEDLL;
function Mappy_GetMatHeight(Mappy:integer):integer;cdecl;external HGEDLL;
procedure Mappy_ChangeLayer(Mappy,Layer:integer);cdecl;external HGEDLL;
procedure Mappy_CreateParallax(Mappy:integer; Filename:pchar);cdecl;external HGEDLL;
function Mappy_DrawParallax(Mappy:integer;depth:single;color:dword;blend:integer):boolean;cdecl;external HGEDLL;

function Mappy_RectColideInPixels(Mappy:integer;x,y,w,h:single):boolean;cdecl;external HGEDLL;
function Mappy_RectColide(Mappy:integer;x,y,w,h:single):boolean;cdecl;external HGEDLL;

//__________________________________________________________________________________________________------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
function Movie_LoadFromFile(const FileName:pchar;x,y,w,h:integer):boolean;cdecl;external HGEDLL;
procedure Movie_Update;cdecl;external HGEDLL;
procedure Movie_Free;cdecl;external HGEDLL;
procedure Movie_Play();cdecl;external HGEDLL;
procedure Movie_Pause();cdecl;external HGEDLL;
procedure Movie_Stop();cdecl;external HGEDLL;
function Movie_Finished:boolean;cdecl;external HGEDLL;

procedure Video_Create(filename:pchar;playmode:integer);cdecl;external HGEDLL;
procedure Video_Update();cdecl;external HGEDLL;
procedure Video_Draw( x, y, w, h:single;blend:integer);cdecl;external HGEDLL;
procedure Video_Play;cdecl;external HGEDLL;
procedure Video_Stop;cdecl;external HGEDLL;
procedure Video_Pause;cdecl;external HGEDLL;
function Video_State:integer;cdecl;external HGEDLL;
procedure Video_Free;cdecl;external HGEDLL;
//**********************************************************+
{
“r” Open a file for reading read from start error
“w” Create a file for writing destroy contents create new
“a” Append to a file write to end create new
“r+“Open a file for read/write read from start error
“w+“Create a file for read/write destroy contents create new
“a+“Open a file for read/write write to end create new
“b“Binary mode ex "rb" or "r+b"
}
function File_Create(FileName, Mode:pchar):void;cdecl;external HGEDLL;
procedure File_Free(CFile:void);cdecl;external HGEDLL;
function File_Write(CFile:void;const buffer;sizeToWrite:DWORD):integer;cdecl;external HGEDLL;
function File_Read(CFile:void;var buffer;sizeToWrite:integer):integer;cdecl;external HGEDLL;
// if relativePosition=true, the pos is changed relative to current pos, otherwise from begin of file
function File_Seek(CFile:void; finalPos:DWORD; relativePosition:boolean= false):boolean;cdecl;external HGEDLL;
function File_Pos(CFile:void):integer;cdecl;external HGEDLL;
function File_Size(CFile:void):integer;cdecl;external HGEDLL;
function File_IsOpen(CFile:void):boolean;cdecl;external HGEDLL;

function Stream_Create(memory:pointer;DWORD:integer;FreeMemOnDestroy:boolean=true):void;cdecl;external HGEDLL;
procedure Stream_Free(CFile:void);cdecl;external HGEDLL;
function Stream_Write(CFile:void;const buffer;sizeToWrite:DWORD):integer;cdecl;external HGEDLL;
function Stream_Read(CFile:void;var buffer;sizeToWrite:DWORD):integer;cdecl;external HGEDLL;
// if relativePosition=true, the pos is changed relative to current pos, otherwise from begin of file
function Stream_Seek(CFile:void; finalPos:DWORD; relativePosition:boolean= true):boolean;cdecl;external HGEDLL;
function Stream_Pos(CFile:void):integer;cdecl;external HGEDLL;
function Stream_Size(CFile:void):integer;cdecl;external HGEDLL;
function Stream_IsOpen(CFile:void):boolean;cdecl;external HGEDLL;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
procedure MikWin_Init;cdecl;external HGEDLL;
procedure MikWin_Free;cdecl;external HGEDLL;
procedure MikWin_Load(filename:pchar);cdecl;external HGEDLL;
procedure MikWin_Play(loop:boolean);cdecl;external HGEDLL;
procedure MikWin_Stop;cdecl;external HGEDLL;
procedure MikWin_Pause;cdecl;external HGEDLL;
procedure MikWin_Paused;cdecl;external HGEDLL;
procedure MikWin_Update;cdecl;external HGEDLL;
function MikWin_Playing:boolean;cdecl;external HGEDLL;
procedure MikWin_SetNumVoices(music, sfx:integer);cdecl;external HGEDLL;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//OPENAL SOUN
procedure Sound_Init ;cdecl;external HGEDLL;
procedure Sound_Close; cdecl;external HGEDLL;
function Sound_PlayFromFile(filename:pchar;loop:boolean=false):integer;cdecl;external HGEDLL;
function Sound_LoadSample(filename:pchar):integer;cdecl;external HGEDLL;
function Sound_Load3DSample( filename:pchar; REFERENCE_DISTANCE:single):integer;cdecl;external HGEDLL;
procedure Sound_EnableListener(index:integer;v:boolean);cdecl;external HGEDLL;
procedure Sound_Play(index:integer;loop:boolean=false);cdecl;external HGEDLL;
procedure Sound_PlayAt(index:integer;loop:boolean;x,y,z:single);cdecl;external HGEDLL;
procedure Sound_Stop(index:integer);cdecl;external HGEDLL;
function Sound_IsPlaying(index:integer):boolean;cdecl;external HGEDLL;
function Sound_GetVolume(index:integer):integer;cdecl;external HGEDLL;
function Sound_GetFrequency(index:integer):integer;cdecl;external HGEDLL;
procedure Sound_SetVolume(index,Volume:integer);cdecl;external HGEDLL;
procedure Sound_SetPitch(index:integer;value:single);cdecl;external HGEDLL;

procedure Sound_SetVelocity(index:integer;x,y,z:single);cdecl;external HGEDLL;
procedure Sound_SetPosition(index:integer;x,y,z:single);cdecl;external HGEDLL;
procedure Sound_SetListenerVelocity(x,y,z:single);cdecl;external HGEDLL;
procedure Sound_SetListenerPosition(x,y,z:single);cdecl;external HGEDLL;
procedure Sound_SetListenerOrientation(x,y,z:single);cdecl;external HGEDLL;
procedure Sound_SetListenerAngle(angle:single);cdecl;external HGEDLL;

function Sound_LoadOggFile( fileName:pchar):integer;cdecl;external HGEDLL;
procedure Sound_PlayOgg(index:integer; loop:boolean);cdecl;external HGEDLL;
procedure Sound_SetOggVolume(index,v:integer);cdecl;external HGEDLL;
procedure Sound_StopOgg(index:integer);cdecl;external HGEDLL;
procedure Sound_UpdateOgg;cdecl;external HGEDLL;
procedure Sound_UpdateOggIndex(index:integer);cdecl;external HGEDLL;
function Sound_OggIsPlay(index:integer):boolean;cdecl;external HGEDLL;

function Sound_SpeakInit(const path:pchar):integer;cdecl;external HGEDLL;
procedure Sound_PrintVoices(language:pchar);cdecl;external HGEDLL;
function Sound_Speak(const speech:pchar;delay:boolean):boolean;cdecl;external HGEDLL;
function Sound_SpeakToFile(const Filename,speech:pchar):boolean;cdecl;external HGEDLL;
procedure Sound_StopSpeak;cdecl;external HGEDLL;
function Sound_SpeakIsPlaying:boolean;cdecl;external HGEDLL;

//gender 0=not specified, 1=male, 2=female
//languages NIL, or a single language string (with optional dialect), eg. "en-uk", or "en"
// age 0=not specified, or an age in years
function Sound_SetSpeakProperties(
const languages:pchar;// // list of pairs of (byte) priority + (string) language (and dialect qualifier)
gender:integer; //0=none 1=male, 2=female,
age:integer):boolean;cdecl;external HGEDLL

function Sound_SetSpeakLanguage(const lang:pchar):boolean;cdecl;external HGEDLL

procedure Sound_SetSpeakSetRate(value:integer );cdecl;external HGEDLL
// speaking speed in word per minute.
procedure Sound_SetSpeakSetVolume(value:integer );cdecl;external HGEDLL
// volume in range 0-100 0=silence
procedure Sound_SetSpeakSetPitch(value:integer );cdecl;external HGEDLL
// base pitch, range 0-100. 50=normal
procedure Sound_SetSpeakSetRange(value:integer );cdecl;external HGEDLL
// base pitch, range 0-100. 50=normal
procedure Sound_SetSpeakPunctuation(value:integer );cdecl;external HGEDLL
// which punctuation characters to announce value is
//PUNCT_NONE=0,
//PUNCT_ALL=1,
//PUNCT_SOME=2
procedure Sound_SetSpeakCapitals(value:integer );cdecl;external HGEDLL
// announce capital letters by:
// 0=none,
// 1=sound icon,
// 2=spelling,
// 3 or higher, by raising pitch. This values gives the amount in Hz by which the pitch
// of a word raised to indicate it has a capital letter.

procedure Sound_SetSpeakWord

PictureFly :: Drag a picture to begin

ignitedPotato — Fri, 19 Feb 2010 03:22:46 -0500

Hi@all!

Just published my "game" on the main site!
It's called - big surprise xD - PictureFly!

A little description:

PictureFly is a small and quite senseless game
but offers much fun!

Load the most horrible pictures of your boss
and kick them around or just have fun
with some shockwaves! :D

Please visit the project website http://picturefly.janik-online.net/ for mor information and download!
At the moment it is win-only.

Test it and give some comments :-)
I would like to hear what you think about it ;-)

Greetz

PS: Please forgive my English whenever it's bad :P

A framework combining HGE, Mappy and Box2D

DLight — Wed, 20 Jan 2010 13:00:05 -0500

Hello All,

I am in middle of writing a framework (a layer over HGE core & helpers) for my upcoming game. This framework is basically to combine HGE, Mappy and Box2D and add few classes such as Entity. Framework also provide facility to update/render a level, set camera position, view-port size etc.

This includes a loader for Mappy levels (FMP format) that work with HGE. Also, to get rid of a bit ugly code :twisted: found in FMP playback libraries, I have written my FMP loader from scratch, which is well structured and extensible. Right now it can load 15, 16 and 32 bit maps of type FMP 0.5 and 1.0.

Next I will be adding Box2D support in my framework so that Entities should have a Box2D body/shape etc. I am also considering Mappy levels' blocks (optionally) tied with Box2D (like 'Wall' blocks to have Box2D bodies).

I have a few questions to the community:
1) How do you see an FMP loader for HGE :?: (later, I will consider making it available to all of you)
2) Would integration of a Mappy maps with Box2D make sense :?: (at least, at my game level, I need this. It is going to be a a top-down shooter style and Player is NOT bound to move 'tile by tile' but it can move freely and collide with level's walls etc) I mean, should it be part of my game or part of framework?

Your suggestions/comments appreciated. :)

Regards

New Game : L!ght Deluxe

nemo games — Tue, 05 Jan 2010 17:54:18 -0500

L!ght Deluxe is a logical puzzle game from Nemo Games with an innovative design. If you're seeking an addictive puzzle game, L!ght Deluxe will be your choice!

We've been using HGE ( Haaf's Game Engine ), DevIL and Audiere to create this game.

Information:

Your main goal is to direct light-rays from lights sources to light receivers! You are provided with tools like mirrors, light filters, prisms, etc. So, is that all there is to this game? You really think?! Well, to get you started on what's going on, yes you CAN manipulate the items to reach your goal, BUT you can't have them to stop where ever you want, not that easily! There are several tutorial through out the game to get you started. We have provided two levels of difficulty, a 'Normal Mode' and a 'Hard Mode'. If you want to challenge your mind play in 'Hard Mode', of course you could always choose 'Normal Mode' to relax your mind and enjoy yourself.

You can create your own levels with the use of our L!ght Deluxe Level Editor and upload them and share them with people all around the world for Free! We will pack the best received levels for you so you can download them from our website therefore you can play a lot of levels designed by other people for Free!

[list]
[*]2 Levels of difficulty.
[*]More than 100 unique levels.
[*]Built-in level editor (the one we used ourselves)
[*]Dynamic background colors.
[*]Perfect musics to concentrate your mind.
[*]Supports add-on musics.
[*]Create and share your own levels.
[/list:u]
Youtube Video:

Game Website:
http://www.nemo-games.com/lightdeluxe.html

Download Free Demo:
http://www.nemo-games.com/games/light-deluxe-demo.html

Buy Now:
http://www.nemo-games.com/lightdeluxe.html

We are pleased to know about your comments.