à ce rythme là, dans 18 jours ce sera fini :-)

@Elwood :
Ben en fait, si tu préfères, lorsque je bosse 1 jeu de commandes.
Il y a souvement une partie longue et ch***** à faire c'est à dire le coeur du jeu de commandes (pour les sprites c'était par exemple la partie de gestion mémoire des backbuffers et la gestion du rendu à l'écran), puis il y a une partie moins compliquée à faire ce sont les commandes de gestion annexe (genre, pour les sprites, changer l'image d'un sprite, le déplacer, etc ...)

C'est pour cela que parfois ... il y a peu de nouvelles commandes (soit 1 commande tout les XXX jours et parfois il y en a +ieurs rapidement ;)

@ +
AmiDARK

Citation : Artblink?
En tous cas, pour le fun, j'adapterai mes prg hollywood sur ton amidark engine...

Vivement qu'il arrive, mais je lacherai pas hollywood, car je le trouve fun

J'aime beaucoup Hollywood, comme Artblink, car il me permet de travailler en 68k (sur divers PC) et maintenant sur OS4 mais j'avoue que je me laisserai également tenter par AmiDARK Engine.
Les démos que tu m'avais montré à l'Alchimie étaient impressionnantes (je n'ai pas trop cherché mais on peut encore les récupérer, histoire de donner à manger à ma SAM?)

@Tarzin :
J'espère pouvoir mettre en ligne d'ici dimanche, les versions d'évaluation publique et de beta test privé ...

@ +
AmiDARK

Très bonne nouvelle est si ça n'est pas la cas, je patienterai.
Merci

J'espère que le moteur 2D de l'Amidark engine pourra m'aider dans le dev de gros jeux 2D.

Va-tu ajouter des commandes spécifique (comme hollywood) tel que le zoom, la rotation de brosse ou sprite, la translation de pixel dans une image (je pense que oui car c'est important pour la texturisation d'objet 3D... je trouve), une commande de scrolling etc...

Tu vas faire une API ou on utilise tjrs codebench ou cubicide?
Le guide des commandes sera t'il en français?

Moaurf.... une démo... une démo ;-)

Salut :)

Citation : artblink?
J'espère que le moteur 2D de l'Amidark engine pourra m'aider dans le dev de gros jeux 2D.
Va-tu ajouter des commandes spécifique (comme hollywood) tel que le zoom, la rotation de brosse ou sprite, la translation de pixel dans une image (je pense que oui car c'est important pour la texturisation d'objet 3D... je trouve), une commande de scrolling etc...
Tu vas faire une API ou on utilise tjrs codebench ou cubicide?
Le guide des commandes sera t'il en français?
Moaurf.... une démo... une démo ;-)?

Voici la liste des commandes de base disponibles dans DarkBASIC Professional :
---------------------------------------------------------------------------------------------
SPRITE : SPRITE Sprite Number, XPos, YPos, Image Number
SET SPRITE : SET SPRITE Sprite Number, Backsave, Transparency
DELETE SPRITE : DELETE SPRITE Sprite Number
CLONE SPRITE : CLONE SPRITE Sprite Number, Destination Sprite Number
SHOW SPRITE : SHOW SPRITE Sprite Number
HIDE SPRITE : HIDE SPRITE Sprite Number
HIDE ALL SPRITES : HIDE ALL SPRITES
SHOW ALL SPRITES : SHOW ALL SPRITES
MOVE SPRITE : MOVE SPRITE Sprite Number, Velocity
OFFSET SPRITE : OFFSET SPRITE Sprite Number, XOffset, YOffset
SCALE SPRITE : SCALE SPRITE Sprite Number, Scale
SIZE SPRITE : SIZE SPRITE Sprite Number, XSize, YSize
STRETCH SPRITE : STRETCH SPRITE Sprite Number, XScale, YScale
ROTATE SPRITE : ROTATE SPRITE Sprite Number, Angle
FLIP SPRITE : FLIP SPRITE Sprite Number
MIRROR SPRITE : MIRROR SPRITE Sprite Number
PASTE SPRITE : PASTE SPRITE Sprite Number, XPos, YPos
CREATE ANIMATED SPRITE : CREATE ANIMATED SPRITE Sprite Number, Filename, Across, Down, Image Number
PLAY SPRITE : PLAY SPRITE Sprite Number, Start Frame, End Frame, Delay Value
SET SPRITE FRAME : SET SPRITE FRAME Sprite Number, Frame Value
SET SPRITE PRIORITY : SET SPRITE PRIORITY Sprite Number, Priority
SET SPRITE IMAGE : SET SPRITE IMAGE Sprite Number, Image Number
SET SPRITE ALPHA : SET SPRITE ALPHA Sprite Number, Alpha Value
SET SPRITE DIFFUSE : SET SPRITE DIFFUSE Sprite Number, Red Value, Green Value, Blue Value
SET SPRITE TEXTURE COORD : SET SPRITE TEXTURE COORD Sprite Number, Vertex Index, UValue, VValue
SET SPRITE RESIZE : SET SPRITE RESIZE Mode

Et des fonctions (qui renvoient une valeur) :
---------------------------------------------------
SPRITE EXIST : Return Integer=SPRITE EXIST(Sprite Number)
SPRITE X : Return Integer=SPRITE X(Sprite Number)
SPRITE Y : Return Integer=SPRITE Y(Sprite Number)
SPRITE OFFSET X : Return Integer=SPRITE OFFSET X(Sprite Number)
SPRITE OFFSET Y : Return Integer=SPRITE OFFSET Y(Sprite Number)
SPRITE SCALE X : Return Integer=SPRITE SCALE X(Sprite Number)
SPRITE SCALE Y : Return Integer=SPRITE SCALE Y(Sprite Number)
SPRITE WIDTH : Return Integer=SPRITE WIDTH(Sprite Number)
SPRITE HEIGHT : Return Integer=SPRITE HEIGHT(Sprite Number)
SPRITE IMAGE : Return Integer=SPRITE IMAGE(Sprite Number)
SPRITE MIRRORED : Return Integer=SPRITE MIRRORED(Sprite Number)
SPRITE FLIPPED : Return Integer=SPRITE FLIPPED(Sprite Number)
SPRITE HIT : Return Integer=SPRITE HIT(Sprite Number, Target Sprite Number)
SPRITE COLLISION : Return Integer=SPRITE COLLISION(Sprite Number, Target Sprite Number)
SPRITE ANGLE : Return Float=SPRITE ANGLE(Sprite Number)
SPRITE FRAME : Return Integer=SPRITE FRAME(Sprite Number)
SPRITE ALPHA : Return Integer=SPRITE ALPHA(Sprite Number)
SPRITE RED : Return Integer=SPRITE RED(Sprite Number)
SPRITE GREEN : Return Integer=SPRITE GREEN(Sprite Number)
SPRITE BLUE : Return Integer=SPRITE BLUE(Sprite Number)
SPRITE VISIBLE : Return Integer=SPRITE VISIBLE(Sprite Number)
SPRITE PRIORITY : Return Integer=SPRITE PRIORITY(Sprite Number)

Elles devraient toutes y être au final ;)
Je pense que tu es rassuré ?
Il y aura aussi dans certains jeux de commandes, des commandes n'existant pas dans DarkBASIC Professional et que je trouvais nécessaire au langage pour le "compléter" un peu plus ...

Pour l'instant, concernant les sprites, il y a toutes ces commandes là :
--------------------------------------------------------------------------------
/* ********************************************************************************************************************************** */
/* 4. Liste des fonctions générales du set SPRITE */
/* ********************************************** */
/* Fonction pour définir le backsaving et la transparence d'un sprite */
// void DESetSprite( int iID, int iBacksave, int iTransparent );
/* Fonction pour créer un nouveau sprite ou le modifier */
// void DESprite( int iID, int iX, int iY, int iImage );
/* Permet de cacher un sprite.Il ne sera pas affiché */
// void DEHideSprite( int iID );
/* Permet de réafficher un sprite précedemment caché par DEHideSprite() */
// void DEShowSprite( int iID );
/* Permet de cacher tous les sprites */
// void DEHideAllSprites( void );
/* Permet de réafficher tous les sprites */
// void DEShowAllSprites( void );
/* Fonction utilisateur de suppression d'un sprite de la mémoire */
// void DEDeleteSprite( ind iID );
/* Définir la priorité d'affichage d'un sprite */
// void DESetSpritePriority( int iID, int iPriority );
/* Fonction utilisateur pour savoir si un sprite existe ou pas */
// int DESpriteExist( int iID );
/* Fonction utilisateur qui renvoie la priorité d'un sprite */
// float DESpritePriority( int iID );
/* Renvoie la position sur X du sprite dans l'écran */
// int DESpriteX( int iID );
/* Renvoie la position sur Y du sprite dans l'écran */
// int DESpriteY( int iID );
/* Renvoie le numéro d'index d'image du sprite */
// int DESpriteImage( int iID );
/* Renvoie la largeur en pixels du sprite dans l'écran */
// int DESpriteWidth( int iID );
/* Renvoie la hauteur en pixels du sprite dans l'écran */
// int DESpriteHeight( int iID );
/* Fonction pour déplacer un sprite existant à l'écran */
// void DEPositionSprite( int iID, int iX, int iY );
/* Fonction pour déplacer un sprite existant à l'écran */
// void DESetSpriteX( int iID, int iX );
/* Fonction pour déplacer un sprite existant à l'écran */
// void DESetSpriteY( int iID, int iY );
/* Change l'image utilisée pour un sprite */
// void DESetSpriteImage( int iID, int iImage );
/* Redimensionne le sprite aux dimensions choisies */
// void DESizeSprite( int iID, int iXSize, int iYSize );
/* Redimensionne le sprite en utilisant un redimensionnement par pourcentage */
// void DEScaleSprite( int iID, float fScale );
/* Redimensionne le sprite en utilisant un redimensionnement par pourcentage */
// void DEStretchSprite( int iID, float iXStretch, float iYStretch );
/* Renvoie la valeur de redimensionnement sur X en pourcentage */
// float DESpriteScaleX( int iID );
/* Renvoie la valeur de redimensionnement sur Y en pourcentage */
// float DESpriteScaleY( int iID );
/* Renvoie la largeur en pixels du sprite */
// float DESpriteWidth( int iID );
/* Renvoie la hauteur en pixels du sprite */
// float DESpriteHeight( int iID );
//

bien entendu cette liste ne représente que les commandes utilisateurs ;)
Le boulot est + complêxe, il y a toutes les fonctions internes qui ne sont pas accessibles à l'utilisateur final de l'AmiDARK Engine ;)

Que veux-tu dire par API ( Advanced Programing Interface ) ?
AmiDARK Engine est, tout comme OpenGL, DirectX, etc ... une API ...
Donc ? Je ne saisis pas ta question ...

Le guide FINAL sera en Anglais & Français.

Sinon, je suis en train de préparer la version r0.4 que je devrais mettre en ligne ce soir ou demain ... la version est quasi prête ... je fignole un peu les démos, complète la doc HTML pour qu'elle informe sur toutes les commandes actuellement disponibles ...

Sinon, juste à titre d'informations, voici la liste de toutes les commandes actuellement disponibles dans le SDK/GDK (enfin, qui le seront dans cette release 0.4) :

/* Basic 2D */
void DEBox( int Left, int Top, int Right, int Bottom );
void DEBoxEx( int Left, int Top, int Right, int Bottom, int Color1, int Color2, int Color3, int Color4 );
void DEDot( int X, int Y );
void DEDotEx( int X, int Y, int RGBColor );
int DEPoint( int X, int Y );
void DEElipse( int X, int Y, int XRadius, int YRadius );
void DEEllipse( int X, int Y, int XRadius, int YRadius );
void DECircle( int X, int Y, int Radius );
void DELine( int X1, int Y1, int X2, int Y2 );
void DEInk( int ForeGroundcolor, int BackgroundColor );
int DERgb( int RedValue, int GreenValue, int BlueValue );
int DERgbR( int RGBColor );
int DERgbG( int RGBColor );
int DERgbB( int RGBColor );
int DERGB( int RedValue, int GreenValue, int BlueValue );
int DERGBR( int RGBColor );
int DERGBG( int RGBColor );
int DERGBB( int RGBColor );
void DECls( void );
void DEClsEx( int ClearRGBColor );
void DESetYAxisToDefault( void );
void DEReverseYAxis( void );

/* Basic 3D */
int GetObjectAmount( void );
int DEMeshExist( int MeshNumber );
void DEChangeMesh( int ObjectID, int LimbNumber, int MeshNumber );
void DEMakeObject( int ObjectID, int MeshNumber, int ImageID );
void DEMakeMeshFromObject( int MeshNumber, int ObjectID );
void DESaveMesh( char *FileName, int MeshNumber );
void DELoadMesh( char *FileName, int MeshNumber );
void DEDeleteMesh( int MeshNumber );
int DENextFreeMesh( void );
void DERotateLimb( int ObjectID, int LimbNumber, float XAngle, float YAngle, float ZAngle );
void DEAddLimb( int ObjectID, int LimbNumber, int MeshNumber );
int DELimbExist( int ObjectID, int LimbNumber );
void DERemoveLimb( int ObjectID, int LimbNumber );
void DEHideLimb( int ObjectID, int LimbNumber );
void DEShowLimb( int ObjectID, int LimbNumber );
void DELinkLimb( int ObjectID, int ParentLimb, int ChildLimb );
int DECheckLimbLink( int ObjectID, int LimbNumber );
void DEOffsetLimb( int ObjectID, int LimbNumber, float X, float Y, float Z );
float DELimbOffsetX( int ObjectID, int LimbNumber );
float DELimbOffsetY( int ObjectID, int LimbNumber );
float DELimbOffsetZ( int ObjectID, int LimbNumber );
void DEScaleLimb( int ObjectID, int LimbNumber, float XSize, float YSize, float ZSize );
float DELimbScaleX( int ObjectID, int LimbNumber );
float DELimbScaleY( int ObjectID, int LimbNumber );
float DELimbScaleZ( int ObjectID, int LimbNumber );
float DELimbDirectionX( int ObjectID, int LimbNumber );
float DELimbDirectionY( int ObjectID, int LimbNumber );
float DELimbDirectionZ( int ObjectID, int LimbNumber );
float DELimbPositionX( int ObjectID, int LimbNumber );
float DELimbPositionY( int ObjectID, int LimbNumber );
float DELimbPositionZ( int ObjectID, int LimbNumber );
float DELimbAngleX( int ObjectID, int LimbNumber );
float DELimbAngleY( int ObjectID, int LimbNumber );
float DELimbAngleZ( int ObjectID, int LimbNumber );
void DEColorLimb( int ObjectID, int LimbNumber, int RGBColor );
void DETextureLimb( int ObjectID, int LimbNumber, int ImageID );
int DELimbTexture( int ObjectID, int LimbNumber );
void DETextureLimbEx( int ObjectID, int LimbNumber, int StageNumber, int ImageID );
void DEScaleLimbTexture( int ObjectID, int LimbNumber, float UScale, float VScale );
void DEScrollLimbTexture( int ObjectID, int LimbNumber, float X, float Y );
void DEMakeObjectBox( int ObjectID, float X, float Y, float Z );
void DEMakeObjectCube( int ObjectID, float Width );
void DEMakeObjectTriangle( int ObjectID, float X1, float Y1, float Z1, float X2, float Y2, float Z2, float X3, float Y3, float Z3 );
void DEMakeObjectPlain( int ObjectID, float Width, float Height );
void DEInstanceObject( int ObjectID, int SourceObject );
void DEDeleteObject( int ObjectID );
void DEDeleteObjects( int ObjectID1, int ObjectID2 );
void DEPositionObject( int ObjectID, float XPos, float YPos, float ZPos );
void DERotateObject( int ObjectID, float XRot, float YRot, float ZRot );
void DESetObjectRotationXYZ( int ObjectID );
void DESetObjectRotationZYX( int ObjectID );
void DEXRotateObject( int ObjectID, float XAngle );
void DEYRotateObject( int ObjectID, float XAngle );
void DEZRotateObject( int ObjectID, float XAngle );
void DEScaleObject( int ObjectID, float XScaleF, float YScaleF, float ZScaleF );
float DEObjectPositionX( int ObjectID ):
float DEObjectPositionY( int ObjectID ):
float DEObjectPositionZ( int ObjectID ):
float DEObjectAngleX( int ObjectID );
float DEObjectAngleX( int ObjectID );
float DEObjectAngleX( int ObjectID );
int DEObjectExist( int ObjectID );
void DEHideObject( int ObjectID );
void DEShowObject( int ObjectID );
int DEIsObjectAlpha( int ObjectID );
int DEIsObjectHidden( int ObjectID );
int DEIsObjectAlpha( int ObjectID );
int DEIsObjectHidden( int ObjectID );
void DEFadeObject( int ObjectID, int FadeValue );
void DEGhostObjectOn( int ObjectID );
void DEGhostObjectOnEx( int ObjectID, int GhostEffect );
void DEGhostObjectOff( int ObjectID );
void DESetObject( int ObjectID, int WireFrame, int Transparent, int Cull );
void DESetObjectEx( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter );
void DESetObjectEx2( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light );
void DESetObjectEx3( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light, int Fog );
void DESetObjectEx4( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light, int Fog, int Ambient );
void DESetObjectWireFrame( int ObjectID, int Flag );
void DESetObjectTransparency( int ObjectID, int Flag );
void DESetObjectCull( int ObjectID, int Flag );
void DESetObjectFilter( int ObjectID, int Flag );
void DESetObjectLight( int ObjectID, int Flag );
void DESetObjectFog( int ObjectID, int Flag );
void DESetObjectAmbient( int ObjectID, int Flag );
void DESetObjectDiffuse( int ObjectID, int RGBColor );
void DESetObjectAmbience( int ObjectID, int RGBColor );
void DESetObjectSpecular( int ObjectID, int RGBColor );
void DESetObjectEmissive( int ObjectID, int RGBColor );
void DESetObjectDiffuseEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectAmbienceEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectSpecularEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectEmissiveEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectSpecularPower( int ObjectID, int Power );
void DESetAlphaMappingOn( int ObjectID, float AlphaPercentage );
void DEColorObject( int ObjectID, int RGBColor );
void DEColorObjectEx( int ObjectID, int RGBR, int RGBG, int RGBB );
void DETextureObject( int ObjectID, int ImageIndex );
void DEScaleObjectTexture( int ObjectID, float UScale, float VScale );
void DEScrollObjectTexture( int ObjectID, float X, float Y );
void DEEnableObjectZWrite( int ObjectID );
void DEDisableObjectZWrite( int ObjectID );
int DEStatistic( int StatisticCode );
void DELoadObject( char * FileName, int ObjectID );

/* Camera 3D */
int DECameraExist( int CameraID );
void DEPositionCamera( float XPos, float YPos, float ZPos );
void DERotateCamera( float XAngle, float YAngle, float ZAngle );
void DEXRotateCamera( float XAngle );
void DEYRotateCamera( float XAngle );
void DEZRotateCamera( float XAngle );
void DEPointCamera( float XPos, float YPos, float ZPos );
void DEMoveCamera( float Distance );
void DEMoveCameraLeft( float fStep );
void DEMoveCameraRight( float fStep );
void DEMoveCameraUp( float fStep );
void DEMoveCameraDown( float fStep );
void DESetCameraRange( int NearValue, int FarValue );
void DESetCameraView( int Left, int Top, int Right, int Bottom );
void DESetCameraRotationXYZ();
void DESetCameraRotationZYX();
void DESetCameraFov( float fieldOfViewAngle );
void DEAutocamON( void );
void DEAutocamOFF( void );
void DETurnCameraLeft( float AngleValue );
void DETurnCameraRight( float AngleValue );
void DEPitchCameraUp( float AngleValue );
void DEPitchCameraDown( float AngleValue );
void DERollCameraLeft( float AngleValue );
void DERollCameraRight( float AngleValue );
void SetCameraToObjectOrientation( int ObjectID );
void DEBackdropOn( void );
void DEBackdropOff( void );
void DEColorBackdrop( int RGBColor );
float DECameraPositionX( void );
float DECameraPositionY( void );
float DECameraPositionZ( void );
float DECameraAngleX( void );
float DECameraAngleY( void );
float DECameraAngleZ( void );
void DEMakeCamera( int CameraID );
void DEDeleteCamera( int CameraID );
void DESetCurrentCamera( int CameraID );
void DEPositionCameraEx( int CameraID, float XPos, float YPos, float ZPos );
void DERotateCameraEx( int CameraID, float XAngle, float YAngle, float ZAngle );
void DESetCameraFovEx( int CameraID, float fieldOfViewAngle );
void DESetCameraRangeEx( int CameraID, float NearValue, float FarValue );
void DESetCameraViewEx( int CameraID, int Left, int Top, int Right, int Bottom );
void DESetCameraRotationXYZEx( int CameraID );
void DESetCameraRotationZYXEx( int CameraID );
void DEXRotateCameraEx( int CameraID, float XAngle );
void DEYRotateCameraEx( int CameraID, float YAngle );
void DEZRotateCameraEx( int CameraID, float ZAngle );
void DEPointCameraEx( int CameraID, float XPos, float YPos, float ZPos );
void DEMoveCameraEx( int CameraID, float Distance );
void DEMoveCameraLeftEx( int CameraID, float fStep );
void DEMoveCameraRightEx( int CameraID, float fStep );
void DEMoveCameraUpEx( int CameraID, float fStep );
void DEMoveCameraDownEx( int CameraID, float fStep );
void DETurnCameraLeftEx( int CameraID, float AngleValue );
void DETurnCameraRightEx( int CameraID, float AngleValue );
void DEPitchCameraUpEx( int CameraID, float AngleValue );
void DEPitchCameraDownEx( int CameraID, float AngleValue );
void DERollCameraLeftEx( int CameraID, float AngleValue );
void DERollCameraRightEx( int CameraID, float AngleValue );
void SetCameraToObjectOrientationEx( int CameraID, int ObjectID );
void DEBackdropOnEx( int CameraID );
void DEBackdropOffEx( int CameraID );
void DEColorBackdropEx( int CameraID, int RGBColor );
float DECameraPositionXEx( int CameraID );
float DECameraPositionYEx( int CameraID );
float DECameraPositionZEx( int CameraID );
float DECameraAngleXEx( int CameraID );
float DECameraAngleYEx( int CameraID );
float DECameraAngleZEx( int CameraID );

/* Core */
float DEWrapValue( float Angle );
float DEWrapValueEx( float Angle );
void DERandomize( int Value );
int DERnd( int RangeValue );
float DECos( float Angle );
float DESin( float Angle );
float DETan( float Angle );
float DEACos( float Angle );
float DEASin( float Angle );
float DEATan( float Angle );
float DEATanFull( float Value, float Value2 );
float DEHCos( float Value );
float DEHSin( float Value );
float DEHTan( float Value );
float DESqrt( float Value );
float DESqr( float Value );
float DEAbs( float Value );
int DEAbsI( int Value );
float DEInt( float Value );
float DEExp( float Value );
float DECOS( float Angle );
float DESIN( float Angle );
float DETAN( float Angle );
float DEACOS( float Angle );
float DEASIN( float Angle );
float DEATAN( float Angle );
float DEATANFULL( float Value, float Value2 );
float DEHCOS( float Value );
float DEHSIN( float Value );
float DEHTAN( float Value );
float DESQRT( float Value );
float DESQR( float Value );
float DEABS( float Value );
int DEABSI( int Value );
float DEINT( float Value );
float DEEXP( float Value );
void DESetCursor( int XPos, int YPos );
void DESyncON( void );
void DESyncOn( void );
void DESyncOFF( void );
void DESyncOff( void );
void DESyncRate( int Rate );
void DESyncMask( int dwMask );
void DESyncCamera( int CameraID );
void DESync();
void WaitForSynchro( void );
void DEPrint( const char *ZeStr );
void DEDrawToBack( void );
void DEDrawToFront( void );
void DESetDebugMode( int ModeID );
uint32 DETimer( void );
void DEBreak( void );
void DEEnableZTrick( void );
void DEDisableZTrick( void );

/* File */
int DEFileOpened( int FileID );
void DEFileOpenToRead( int ChannelID, const char *FileName );
void DEOpenToRead( int ChannelID, const char *FileName );
void DEFileOpenToWrite( int ChannelID, const char *FileName );
void DEOpenToWrite( int ChannelID, const char *FileName );
void DEWriteToFile( int ChannelID, void *MemoryPointer, int BytesSize );
void DEReadFile( int ChannelID, void *MemoryPointer, int BytesSize );
void DEWriteFloat( int ChannelID, float ValueToInsert );
float DEReadFloat( int ChannelID );
void DEWriteLong( int ChannelID, int ValueToInsert );
int DEReadLong( int ChannelID );
void DEWriteInt( int ChannelID, int ValueToInsert );
int DEReadInt( int ChannelID );
void DEWriteString( int ChannelID, const char *ValueToInsert );
void *DEReadString( int ChannelID );
WORD DEReadWord( int ChannelID );
void DEWriteWord( int ChannelID, WORD ValueToInsert );
void DECloseFile( int ChannelID );
void DEFileClose( int ChannelID );
int DENextFreeFile( void );
int DEGetFileSize( int ChannelID );
int DEFileSize( int ChannelID );
int DEFileExist( const char* pFilename );
void DEMakeMemblockFromFileEx( int MemblockID, const char *FileName );

/* Image 2D */
void DELoadImageEx( const char * FileName, int ImageIndex, int ImageMode );
void DELoadImage( const char * FileName, int ImageIndex );
void DEGetImage( int ImageIndex, int iX1, int iY1, int iX2, int iY2 );
void DEDeleteImage( int ImageIndex );
int DEImageExist( int ImageIndex );
int DEImageExistEx( int ImageIndex );
int DEImageWidth( int ImageIndex );
int DEImageHeight( int ImageIndex );
void DEPasteImageEx( int ImageIndex, int X, int Y, int Transparency );
void DEPasteImage( int ImageIndex, int X, int Y );
void DEPasteStretchedImageEx( int ImageIndex, int X, int Y, int Transparency, int Width, int Height );
void DEPasteStretchedImage( int ImageIndex, int X, int Y, int Width, int Height );
void DEFlipImage( int ImageIndex );
void DEUnFlipImage( int ImageIndex );
void DEMirrorImage( int ImageIndex );
void DEUnMirrorImage( int ImageIndex );
void DESetImageAlpha( int ImageIndex, int Alpha );

/* Input */
BOOL DEUpKey( void );
BOOL DEDownKey( void );
BOOL DELeftKey( void );
BOOL DERightKey( void );
BOOL DESpaceKey( void );
BOOL DEEscapeKey( void );
BOOL DEKeyState( int KeyID );
BOOL DEGetKeyState( int KeyID );
int DEScanCode( void );
int DEScancode( void );
int DEMouseX( void );
int DEMouseY( void );
int DEMouseZ( void );
BOOL DEMouseClick( int MButton );
int DEMouseMoveX( void );
int DEMouseMoveY( void );
int DEMouseMoveZ( void );

/* Light 3D */
void DEMakeLight( int LightID );
void DEDeleteLight( int LightID );
void DEColorLight( int LightID, int RGBColor );
void DEColorLightEx( int LightID, int RGBR, int RGBG, int RGBB );
void DEPositionLight( int LightID, float XPos, float YPos, float ZPos );
void DEHideLight( int LightID );
void DEShowLight( int LightID );
void DESetPointLight( int LightID, float X, float Y, float Z );
void DESetSpotLight( int LightID, float fInner, float fOuter );
void DESetDirectionalLight( int LightID, float NX, float NY, float NZ );
void DESetLightRange( int LightID, float LDistance );
void DESetNormalizationOn( void );
void DESetNormalizationOff( void );
void DESetAmbient( int Percent );
int DEGetAmbient( void );
void DESetAmbientColor( int RGBColor );
void DESetAmbientColorEx( int RGBR, int RGBG, int RGBB );
void DEFogON( void );
void DEFogOFF( void );
void DEFogColor( int RGBValue );
void DEFogColorEx( int FRED, int FGREEN, int FBLUE );
void DEFogDistance( int Distance );
void DEFogStart( int FSTART );
void DEFogDensity( int FDENSITY );
void DEFogMode( int FMODE );
int DELightExist( int LightID );
int DEGetLightExist( int LightID );
int DELightType( int LightID );
float DeLightPositionX( int LightID );
float DELightPositionY( int LightID );
float DELightPositionZ( int LightID );
float DELightDirectionX( int LightID );
float DeLightDirectionY( int LightID );
float DELightDirectionZ( int LightID );
float DELightRange( int LightID );
void DESetLightSpecular( int LightID, float fA, float fR, float fG, float fB );
void DESetLightAmbient( int LightID, float fA, float fR, float fG, float fB );
void DESetLightFalloff( int LightID, float fValue );
void DESetLightAttenuation0( int LightID, float fValue );
void DESetLightAttenuation1( int LightID, float fValue );
void DESetLightAttenuation2( int LightID, float fValue );
void DESetLightSpecularOn( void );
void DESetLightSpecularOff( void );

/* Memblocks */
void DEMakeMemblock( int MemblockID, int MBCSize );
void DEDeleteMemblock( int MemblockID );
int DEMemblockExist( int MemblockID );
void *DEGetMemblockPTR( int MemblockID );
int DEGetMemblockSize( int MemblockID );
int DENextFreeMemblock( void );
void DEWriteMemblockByte( int MemblockID, int MemblockPOS, BYTE VALUE );
BYTE DEMemblockByte( int MemblockID, int MemblockPOS );
void DEWriteMemblockWord( int MemblockID, int MemblockPOS, WORD VALUE );
WORD DEMemblockWord( int MemblockID, int MemblockPOS );
void DEWriteMemblockLong( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockLong( int MemblockID, int MemblockPOS );
void DEWriteMemblockInt( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockInt( int MemblockID, int MemblockPOS );
void DEWriteMemblockDWord( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockDWord( int MemblockID, int MemblockPOS );
void DEWriteMemblockFloat( int MemblockID, int MemblockPOS, float VALUE );
float DEMemblockFloat( int MemblockID, int MemblockPOS );

/* Music */
void DELoadMusic( char * FileName, int iID );
void DEDeleteMusic( int iID );
void DEPlayMusic( int iID );
void DEStopMusic( int iID );
void DEPauseMusic( int iID );
void DEResumeMusic( int iID );
void DESetMusicVolume( int iID, int iVolume );
int DEMusicExist( int iID );
int DEMusicPlaying( int iID );
int DEMusicLooping( int iID );
int DEMusicPaused( int iID );
int DEMusicVolume( int iID );

/* Setup */
int DEScreenFPS( void );
void DESetDisplayMode( int Width, int Height, int Depth );
int DEScreenDepth( void );
int DEScreenHeight( void );
int DEScreenWidth( void );
void DEShowWindow( void );
void DEHideWindow( void );
void DEMinimizeWindow();
void DESetWindowOn( void );
void DESetWindowOff( void );
void DESetWindowSize( int Width, int Height );
void DESetWindowPosition( int XPos, int YPos );
void DESetWindowTitle( char *WTitle );

/* Preliminary Sound Support */
void DELoadSound( char *szFilename, int iID );
void DEDeleteSound( int iID );
int DESoundExist( int iID );

/* Sprites 2D */
void DESetSprite( int iID, int iBacksave, int iTransparent );
void DESprite( int iID, int iX, int iY, int iImage );
void DEHideSprite( int iID );
void DEShowSprite( int iID );
void DEHideAllSprites( void );
void DEShowAllSprites( void );
void DEDeleteSprite( ind iID );
void DESetSpritePriority( int iID, int iPriority );
int DESpriteExist( int iID );
float DESpritePriority( int iID );
int DESpriteX( int iID );
int DESpriteY( int iID );
int DESpriteImage( int iID );
int DESpriteWidth( int iID );
int DESpriteHeight( int iID );
void DEPositionSprite( int iID, int iX, int iY );
void DESetSpriteX( int iID, int iX );
void DESetSpriteY( int iID, int iY );
void DESetSpriteImage( int iID, int iImage );
void DESizeSprite( int iID, int iXSize, int iYSize );
void DEScaleSprite( int iID, float fScale );
void DEStretchSprite( int iID, float iXStretch, float iYStretch );
float DESpriteScaleX( int iID );
float DESpriteScaleY( int iID );
float DESpriteWidth( int iID );
float DESpriteHeight( int iID );

/* System */
int DESystemTMEMAvailable( void );
int DESystemDMEMAvailable( void );
int DESystemSMEMAvailable( void );
int DESystemTmemAvailable( void );
int DESystemDmemAvailable( void );
int DESystemSmemAvailable( void );
void CopyMemory( void *MemBlockStart, int Size, void *MemBlockTarget );
int BitTest( int Var, int BitID );
int TestBit( int Var, int BitID );
int SetBit( int Var, int BitID );
void BitSet( int *Var, int BitID );
void ClearBit( int *Var, int BitID );
void BitClear( int *Var, int BitID );
void DEDisableEscapeKey( void );
void DEDisableEscapekey( void );
void DEEnableEscapeKey( void );
void DEEnableEscapekey( void );
void DEEmptyChecklist( void );
int DEChecklistQuantity( void );
int CheckListForValue( int iIndex );
int CheckListForString( int iIndex );
int DEChecklistValueA( int iIndex );
int DEChecklistValueB( int iIndex );
int DEChecklistValueC( int iIndex );
int DEChecklistValueD( int iIndex );
float DEChecklistFValueA( int iIndex );
float DEChecklistFValueB( int iIndex );
float DEChecklistFValueC( int iIndex );
float DEChecklistFValueD( int iIndex );
char* DEChecklistString( int iIndex );

/* Text */
int DEAsc( char * dwSrcStr );

/* Vectors & 3D Maths */
float Distance3D( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );
float FindXAngle( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );
float FindYAngle( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );


Allez,
Je vais au boulot :p
@ +
AmiDARK
http://www.amidark-engine.com

Mouarf!!! j'adore


Par contre, il faudra donc définir le type de variable, entre entier, chaine, booleen? se sera pas géré automatiquement par le langage?

Une déclaration de variable se fera donc ainsi (en gros)?

int Variable1=0
Float Variable2=0.2
Bool Variable3=False
Char Variable4="Bonjour"

Prg principale
[
...
]

@ArtBlink :

l'AmiDARK Engine reste une API pour le C/C++
Donc, ton utilisation des variables devra être fait comme en C/C++
Ton exemple est quasi juste :

int MonEntier = 0;
float MonFlottant = 0.2f;
BOOL MonBool = FALSE;
char MonTexte = "Bonjour";

Cependant, lorsque l'AmiDARK Engine sera fini, j'attaquerai la suite du projet, l'AmiDARK BASIC qui lui sera un langage basic plus proche de DarkBASIC v1 / DarkBASIC Professional.
Cependant, les langages basic de maintenant, demandent tout de même que l'on initialise la variable par un type. Sinon, un type par défaut (par exemple "int") est choisi.
Après, le langage AmiDARK BASIC pourra lui même faire la projection (casting) du type de données sans que l'utilisateur n'ait à le faire ... ce sera le "pré-compiler" qui le fera ;)

@ +
AmiDARK
http://www.amidark-engine.com

vivement la suite.. mon AmOS4 fait pâle figure à coté, mais bon il est là juste pour pouvoir faire tourner les vieux programme AMOS sous OS4 et avoir une programmation comme le proposait AMOSPro à l'époque..

Merci AmiDark!!!