¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Justement c´est bien pour ca que j´ai préféré commencer à travailler AVANT de monter également ma propre boite avec des potes. Ne serait-ce que pour voir comment fonctionne la vie en entreprise. Donc excuse moi mais côté emploi,entretien,recrutement je pense ne pas avoir à apprendre quoique que ce soit venant de toi sachant que j´en suis pas à ma première année de travail ni mon premier emploi...
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

tu dit ca apres t´etre foutus de ma gueule a base de "c´est vrai que tu as au moins 10-15 ans d´expérience lol : ) à 30 ans tu seras le maître du monde ! "

je suis convaincu d´avoir des choses a t´apprendre, et inversement...car tu devrais savoir qu´il y as des gens qui bossent des années et qui n´en sortent pas pour autant grandit...

¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
re-faux surtout dans le milieu du jeu vidéo.. sache qu´un entretien "type" se déroule toujours en 2/3 phases. Une première partie assez générale pour faire connaissance et se présenter et la deuxième partie plus technique avec les responsables techniques justement qui peuvent sans hésiter éjecter un Bac+5 qui débute face à un autre moins diplômé qui sait déjà faire des choses et qui peut leur apporter ses connaisances.
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

bien sur..c´est vrai que idéalement ca se passe comme ca..mais pas toujours...car malheureusement...entre un mec bien sans diplome et un mec bien avec diplome...ce dernier passeras devant..calcul simple comme le tiens...prendre le cas d´un mec sans diplome mais bon, et un sans diplome mais mauvais, c´est resummé trop facilement les recutements.....entre un bon diplomé, et un bon non diplomé, ton calcul ne s applique pas...

en tout cas je comprend pas tes reactions ma foi, virulante a mon egard, a base de ricanement ou de "FAUX", qui pour quelqu un qui se dit avoir de l experience et 29a....o0...ce n´est que mon avis , mon experience, je n´est jamais chercher a remettre en questions l´experience de chacun ( bien qu´ayant conscience qu´il y as une majeure partie de non-travailleur) je je prefere tenir des propos comme les miens plutot que de compter sur ma bonne etoile comme semble le faire Juju....le monde du travail , n´est pas ainsi, selon moi, je rajoute pour eviter d´autre confrontation vaines...et il n´y as pas de FAUX... ou de VRAI... par contre...prendre des precautions...c´est toujours ca de gagner..

j´oublie une chose...:)

¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

les patrons pensent enormement....diplomes..

re-faux surtout dans le milieu du jeu vidéo.. sache qu´un entretien "type" se déroule toujours en 2/3 phases. Une première partie assez générale pour faire connaissance et se présenter et la deuxième partie plus technique avec les responsables techniques justement qui peuvent sans hésiter éjecter un Bac+5 qui débute face à un autre moins diplômé qui sait déjà faire des choses et qui peut leur apporter ses connaisances.
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

T´oublie une chose..cruciale...avant d´entretenir quelqu un.....il y a sun tri fait a partir du CV, etc....et quant il y as beaucopup de demande..Crois qmoi que le tri se fait en regardant le niveau d´etude....garant d´un serieux...c´est comme ca que ma boite a fait...et c´est comme ca que je me suis fait recruter avant...parce que je sortais d´une ecole d´art...

arf : )
C´est bien pour ca que je terminais en disant : faites les 2 ! travaillez les jeux vidéo chez vous comme passion et continuer vos études pour accéder à des postes intéressants et mieux payés.

Concernant les CV c´est pas suffisant, la lettre de motivation/l´accroche et la présentation est souvent bien plus importante que le contenu même du CV.

Ce que cherchent les recruteurs c´est de trouver le profil le mieux adapté au poste proposé. Il arrive même que trop de diplômes soient un handicap : ) tout dépend du poste

Mais bon les techniques sont jamais les mêmes... Très souvent tu as une grille de compétences à avoir pour le poste ( connaître ceci ou cela, être comme ci ou comme ca), une fourchette de salaire à proposer ( fixée par la direction ou en fonction d´un budget), et tu fais la correpondance avec la pile de CV. Alors ok si Bac+5 fait partie de mentions requises comme dans les grandes boites style Aérospatiale, les grands comptes & Cie faut pas chercher plus loin et tenter le diable avec un Bac+2 ou +3. Mais l´industrie des jeux vidéo fonctionne beaucoup plus sur les connaissances de ce milieu ( que l´on ne t´apprend pas à l´école pour l´instant, pas suffisament) que les diplômes.

Déjà les CV mal présentés sont éjectés car une mauvaise présentation PEUT signifier beaucoup de choses négatives ( ce n´est pas une fatalité mais le recruteur n´est pas là pour se poser la question ou tenter de décoder un CV bordelique).

Ensuite si les compétences requises ne sont pas mentionnées, tu as droit à la fameuse lettre type "Après avoir étudié votre candidature, nous avons le regret . .. blablabla"

Enfin bref, à chacun ses techniques et ses convictions mais ne pensez pas que l´affaire est dans le sac parceque vous sortez de telle ou telle école ( normalement vous n´êtes pas les seuls diplômés sur une année... alors la concurrence existe forcément) : ) le seul moyen de vous départager sera la motivation, la présentation et vos connaissances extra-scolaires ( vos propres réalisations) : )

si tu veux voir le pacman donne moi ton mail je te l envoye....

Mes des photos sur ton site, on ne veut pas se récuperer un virus!!!

mettre des fotos de mes projets sur un site...mmm je vais étudier la question . ..
ca peut etre pas mal...

A la rigueur juste un lien vers des photos, sans la peine un site bien construit derrière.

Surtout que je ne donne jamais mon adresse sur ce genre de forum, car tout le monde passe, et on ne sait jamais qui peut la prendre ( genre un TDC qui t´embete après)

oui tu n a peu etre pas tord...
mais moi je ne me connecte jamais de chez moi toujours du travail...

bon en juin j ai fini 3d et je pars peut etre a paris pour 2 ans encore dans la 3d.
et la je serai au top du top.
mais bon on a le temps.en attendant je vais me mettre a fond dans mon travail.

une fois je suis allé dans une boite de jeu pour demander ce qu´ils recherche comme personnes et ils m´ont repondu : "des personnes ayant fait plus de 2 ans apres le bac et qui connaissent la plupart des langages de programmation utilisé dans le domaine et principalement le C++
au fait si tu apprend a te servir de 3d max bin je tiens a te dire que mon frere a 8ans et arrive a faire des trucs pas mal sans avoir rien appris de plus il arrive a faire la difference entre le basic le c++ et le java(ses deux derniers qui sont assé similaire)et je suis certain que toi tu n´arriverais meme pas a faire la difference!
tien au fait regarde a quoi ressemble un code source : C´est juste pour faire des flammes

/*------------------------------------------------
----------------------------*
| |
| Dessiner des Flammes, Unité principale ( Feu.cpp) |
| |
| programmé par Blustuff |
| |

• -------------------------------------------------

---------------------------*/

/*------------------------------------------------
----------------------------*
| Includes |

• -------------------------------------------------

---------------------------*/

1. include <windows.h>
2. include "affichage.cpp"

//Uniquement pour Borland ( Les lignes suivantes permette la liaision des librairies DirectDraw) :

1. include <condefs.h>

USELIB("..\mssdk\lib\borland\dxguid.lib");
USELIB("..\mssdk\lib\borland\ddraw.lib");

/*------------------------------------------------
----------------------------*
| Variables Globales |

• -------------------------------------------------

---------------------------*/

bool FinDeProgramme = false;

/*------------------------------------------------
----------------------------*
| Fonction WindowProc |

• -------------------------------------------------

---------------------------*/

1. pragma argsused //La fonction suivante n´utilise pas tous ses parametres

LRESULT CALLBACK WindowProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
switch ( uMsg)
{
case WM_KEYDOWN :
if ( wParam == VK_ESCAPE)
FinDeProgramme = true; //Quitter le programme lors de l´appui sur escape
break;

default : return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

return 0;
}

/*------------------------------------------------
----------------------------*
| Initialisation de la fenêtre |

• -------------------------------------------------

---------------------------*/

bool InitialisationFenetre(HINSTANCE hInstance, HWND* hWnd)
{
*hWnd = 0;

WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = ( WNDPROC) WindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(DWORD);
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = ( HBRUSH) GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = "XmplHr17Class";

if ( !RegisterClass(&))
return false;

if ( !(*hWnd = CreateWindow("XmplHr17Class", "Line Race", WS_VISIBLE|WS_POPUP, 0, 0, 0, 0, NULL, NULL, hInstance, NULL)))
return false;

ShowCursor(false); //Cacher le curseur de la souris

return true;
}

/*------------------------------------------------
----------------------------*
| Fonction WinMain |

• -------------------------------------------------

---------------------------*/

1. pragma argsused //La fonction suivante n´utilise pas tous ses parametres

WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
HWND hWnd;
MSG msg;

if ( !InitialisationFenetre(hInstance, &))
return 0;

if ( !InitialiseAffichage(hWnd))
FinDeProgramme = true;

AfficherTexte(SurfaceTexte, "Blustuff Blue Fire", 0, 0, false, 0x00ff0000); //Afficher le texte sur la surface de texte

while ( !FinDeProgramme)
{
if ( PeekMessage(&, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&);
DispatchMessage(&);
}
else
{
DessinerFlammes(); //Dessiner les flammes
RECT Destination = {0,0,200,50};
SurfaceSecondaire->BltFast(40, 130, SurfaceTexte, &, DDBLTFAST_SRCCOLORKEY);//Ecire le texte
SurfacePrimaire->Flip(0,DDFLIP_DONOTWAIT); //Afficher la surface
}
}

DesallocationAffichage();
return 0;
}

/*------------------------------------------------
----------------------------*
| |
| Dessiner des Flammes, Unité d´affichage V.1.0 ( Affichage.cpp) |
| |
| programmé par Blustuff |
| |

• -------------------------------------------------

---------------------------*/

/*
Note du programmeur :

- Ce programme utilise DirectDraw pour initialiser l´affichage, mais accede
par ses propres fonctions a la mémore vidéo pour la modifier. La connaissance
de DirectDraw n´est pas importante, la fonction DessinerFlamme et la seulle
qui puisse etre interessante ici.

- Ce programme n´est pas entièrement optimisé en rapidité. Cela pour diverse
raison ( j´ai la flemme), dont la lisibilité du code qui doit rester a peu près
acceptable

- Note lexicale : Une interface est une structure de base de DirectX, dont
chaque autre élément,DirectDraw, DirectSound, DirectInput etc. hérite. Elle
possède notament la fonction Release() qui permet de désallouer la mémoire qui
lui était réservée.
Une Surface est un emplacement en mémoire contenant des
données susceptible d´etre affichée, a l´ecran ou sur une autre surface.

- J´ai horreur des termes en anglais dans une programme, parce que j´aime bien
rapeller que les francais ont réalisé les plus beaux programme jusqu´a
maintenant. Si j´ai laissé des noms de variables en anglais, veuillez m´en
excuser. ( Celles de DX j´y suis pour rien)

- Je n´ai pas tout inventé tout seul. J´ai repris cet algorythme de Franck
Bauquier ( defcon1@caramail.com) sur son site http://defcon1.free.fr/ . J´ai
juste personalisé les flammes et adapté le programme pour DirectDraw

- Les flammes sont bleues. Ca simplifie vraiment le programme. Si vous voulez
faire des flammes avec autre chose, il faut revoir une bonne partie du code.
Les flammes doivent etre traitées couleur par couleur. Si vous voulez faire des
flammes violettes, vous devez traiter le rouge et le bleu séparement. Mon
programme ne s´y adapte pas ( Et puis j´aime bien le bleu).

Pour me contacter :

blustuff@wanadoo.fr
http://perso.wanadoo.fr/blustuff/

• /

/*------------------------------------------------
----------------------------*
| Fichier d´en tête |

• -------------------------------------------------

---------------------------*/

1. include "affichage.h"

/*------------------------------------------------
----------------------------*
| Initialisation |

• -------------------------------------------------

---------------------------*/

/*
N´essayez pas trop de vous lancer dans la comprehension du code de
l´initialisation graphique de DirectDraw si vous n´avez jamais programmé avec
DirectX. J´appelle ici de nombreuse fonctions que je n´expliquerai pas

• /

bool InitialiseAffichage(HWND hWnd)
{
DDSURFACEDESC2 ddsd;
DDSCAPS2 ddscaps;

//Creation de l´interface DirectDraw
if ( DirectDrawCreateEx(NULL, ( void**)&, IID_IDirectDraw7, NULL) ! = DD_OK)
return false;

//Selection du niveau cooperatif
if ( InterfaceDirectDraw->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT) ! = DD_OK)
return false;

. ..

//Choix du mode d´affichage
if
(InterfaceDirectDraw->SetDisplayMode(LargeurEcran,
HauteurEcran, 32, 0, 0) ! = DD_OK)
return false;

//Creation des surfaces primaires et secondaires
ZeroMemory(&, sizeof(ddsd));
ZeroMemory(&, sizeof(ddscaps));
ddsd.dwSize = sizeof( ddsd ) ;
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;

if ( InterfaceDirectDraw->CreateSurface(&, &, NULL) ! = DD_OK)
return false;

//Association du back Buffer
if ( SurfacePrimaire->GetAttachedSurface(&, &) ! = DD_OK)
return false;

//Effacement des surfaces
EffacerSurface(SurfacePrimaire);
EffacerSurface(SurfaceSecondaire);

//Création et effacement d´une surface réservée au texte
ZeroMemory(&,sizeof(ddsd));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT ;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = 200;
ddsd.dwHeight = 50;

InterfaceDirectDraw->CreateSurface(&, &, NULL);

DDCOLORKEY key;
key.dwColorSpaceLowValue = 0x00000000;
key.dwColorSpaceHighValue = 0x00000000;
SurfaceTexte->SetColorKey(DDCKEY_SRCBLT, &);
EffacerSurface(SurfaceTexte);

//Stockage dans un tableau des valeurs en octet pour le débur de chaque ligne de l´ecran
SurfacePrimaire->Lock(NULL, &, DDLOCK_WAIT, NULL); //Obtention des propriétés de la surface
SurfacePrimaire->Unlock(NULL);

AlignY = ( int*) malloc(ddsd.dwHeight * sizeof(int));
for ( unsigned int y = 0 ; y < ddsd.dwHeight ; y++)
AlignY[y] = ddsd.lPitch * y / 4;

//La fonction retourne true si l´initialisation réussit

return true;
}

/*------------------------------------------------
----------------------------*
| Desallocation Affichage |

• -------------------------------------------------

---------------------------*/

/*
Desallocation de l´affichage : Cette fonction libère l´espace alloué par
DirectDraw. Il faut vérifier que ces interface aient été allouées d´où
l´importance d´initialiser les pointeurs vers elle à NULL. Lorsque les
interfaces sont initialisée, le pointeur prend donc leur adresse, et on sait
donc que l´on peut les désallouer. Voici donc l´interet de verifier la
non-nullité des pointeurs vers les interfaces avant d´appeler Release()

• /

void DesallocationAffichage()
{
free(AlignY);

if ( SurfaceTexte)
SurfaceTexte->Release();
if ( SurfaceSecondaire)
SurfaceSecondaire->Release();
if ( SurfacePrimaire)
SurfacePrimaire->Release();
if ( InterfaceDirectDraw)
InterfaceDirectDraw->Release();
}

/*------------------------------------------------
----------------------------*
| Affichage de texte ( Fonction GDI) |

• -------------------------------------------------

---------------------------*/

/*
Cette fonction fait appel a une fonction GDI de Windows pour afficher du
texte, cela grace a la compatibilité de DirectX, qui fournit un handle context
( hdc) pour permetre a la fonction TextOut d´ecrire sur cette surface. Ici on ne
voit pas très bien le fonctionement interne de l´affichage de texte. Il est en
réalité plus compliqué puisque DirectX doit informer la fonction GDI de la
taille de la surface, de son format de pixels, etc. Ca n´a ici aucune
importance. Cette fonction est lente, mais l´affichage de texte ne recquiert pas
une grande rapidité. J´ai donc préféré la simplicité a la rapidité. ( J´espère
que vous ne m´en voulez pas trop : ) )

• /

void AfficherTexte(LPDIRECTDRAWSURFACE7 Surface, char* Text, int X, int Y, bool Center, DWORD TextColor, DWORD BackColor)
{
if ( InterfaceDirectDraw) //La fonction s´eecute que si l´affichage est initialisé
{
HDC hdc;
if ( Surface->GetDC(&) == DD_OK) //Creer un contexte de dessin et bloquer la surface pour cet usage
{
if ( Center)
SetTextAlign(hdc, TA_CENTER); //Centrer le texte sur ( x,y) si Center est spécifié
else
SetTextAlign(hdc, TA_LEFT | TA_TOP); //Sinon ( x,y) corespond au coin haut droit du cadre de texte

SetTextColor(hdc,TextColor); //Selection de la couleur du texte
SetBkColor(hdc,BackColor); //Et du fond
TextOut(hdc, X, Y, Text, strlen(Text)); //Ecrire le texte
Surface->ReleaseDC(hdc); //Débloquer la surface pour qu´elle puisse etre réutilisée normalement
}
}
}

/*------------------------------------------------
----------------------------*
| Effacer une surface |

• -------------------------------------------------

---------------------------*/

/*
Cette fonction efface une surface quatre octets par quatre octets. Elle est
optimisée

• /

void EffacerSurface(LPDIRECTDRAWSURFACE7 Surface)
{
if ( InterfaceDirectDraw) //La fonction s´eecute que si l´affichage est initialisé
{
DDSURFACEDESC2 ddsd;
ddsd.dwSize = sizeof(ddsd);

if ( Surface->Lock(NULL, &, DDLOCK_WAIT, NULL) == DD_OK) //Bloquer la surface pour l´ecriture
{
register int* FinDeSurface = ( int*)((char*)ddsd.lpSurface + ddsd.dwHeight * ddsd.lPitch); //Fin de la surface ( lPitch est le nombre d´octets entre deux lignes)
for ( register int* x = ( int*)ddsd.lpSurface ; x < FinDeSurface ; x++)
*x = 0;

Surface->Unlock(NULL); //Debloquer la surface pour usage posterieur
}
}
}

/*------------------------------------------------
----------------------------*
| Dessiner les Flammes |

• -------------------------------------------------

---------------------------*/

/*
Voici la fonction interessante : Elle va dessiner les flammes. J´ai tout
d´abord défini des macros pour obtenir la valeur d´un pixel et une pour changer
la valeur d´un pixel. Elle sont optimisés pour le mode d´affichage en couleur
32 bits , mais ne vérifient jamais si le pixel est hors ecran, ce qui est
dangereux si on controle mal son usage.

Ensuite viens la fonction proprement dite. Elle suit l´algorythme suivant :
On trace d´abord une ligne de pixels aléatoirement ( appelée foyer). Dans cet
exemple elle n´est pas réelement aléatoire. J´ai choisi de faire suivre aux
couleurs une fonction sinusoidale irégulière. C´est a dire que l´angle
n´évolue pas uniformenent. Cela donerait si on voulait tracer la courbe
représentative de la fonction, des formes courbes mais sans direction apparente
ni periode.

L´étape suivante consiste a fiare partir les flammes du foyer. Ici j´ai
choisit d´attribuer a chaque pixel la valeur moyenne des pixels inferieurs ( bas
gauche, bas milieu, bas droit). Cela permet d´avoir une continuité dans les
flammes. J´ai mis un plus fort coeficient devant le pixel juste en dessous, de
telle sorte que les flammes soient plus fines. J´ai ajouté a cette moyenne la
couleur du pixel précédent a la même place. Cela donne encore une continuité
mais cette fois-ci dans le temps.

L´effet d´ondulation est effectué par un décalage ( quie j´ai appelé z) de
chaque ligne suivant la fonction sinus. Pour que L´ondulation ne soit pas
régulière, j´ai décalé l´angle de départ de la fonction sinus a chaque affichage
d´une valeur aléatoire ( c).

Il faut que la pointe des flammes soit plus faible. Avant l´affichage de
chaque pixel, on décrémente donc sa valeur de 1. De cette manière le foyer est
nécessairement le plus lumineux.
Il y a bien sur d´autre algorythmes, et d´autre effet pour dessiner des
flammes.

• /

1. define GetLastPixel(X, Y) ( *((int*)ddsd1.lpSurface + AlignY[(Y)] + ( X))) //Obtention de la couleur du pixel sur la Surface Primaire ( Couleur précédente)
2. define GetCurrentPixel(X, Y) ( *((int*)ddsd2.lpSurface + AlignY[(Y)] + ( X))) //Obtention de la couleur du pixel sur la Surface Secondaire ( Couleur courante)
3. define SetPixel(X, Y, Couleur) ( *((int*)ddsd2.lpSurface + AlignY[(Y)] + ( X)) = ( int)(Couleur)) //Définition de la couleur d´un pixel sur la surface secondaire

void DessinerFlammes()
{
if ( InterfaceDirectDraw)
{
DDSURFACEDESC2 ddsd1, ddsd2;
ddsd1.dwSize = ddsd2.dwSize = sizeof(DDSURFACEDESC2);

//Blocage des surfaces pour pouvoir y dessiner
if ( SurfacePrimaire->Lock(NULL, &1, DDLOCK_WAIT, NULL) == DD_OK &&
SurfaceSecondaire->Lock(NULL, &2, DDLOCK_WAIT, NULL) == DD_OK)
{
float c;

//Tracé du foyer
for ( int x = 10 ; x < LargeurEcran-12 ; x++, c += ( float(random(100)-50)/140)) //Changer 140 par une valeur plus grande pour avoir des flammes au foyer plus fin
SetPixel(x, 180, ( sin(c)+1)/2*(ddsd1.ddpfPixelFormat.dwBBitMask)); //ddsd1.ddpfPixelFormat.dwBBitMask est la couleur bleue. Par ailleur : 0 < sin(c)+1)/2 < 1

c += random(100); //Décalage d´angle pour la fonction sinus

for ( register int y = 179 ; y > 60 ; y--) //Tracé du corps de la flamme
{
int z = sin((float)y/5+c)*2; //Décalage de chaque ligne pour l´ondulation
for ( register int x = 1 ; x < LargeurEcran-2 ; x++) //Tracé de la ligne de flamme
{
int NouvelleCouleur;

//Calcul de la couleur moyenne
if ( NouvelleCouleur = ( GetCurrentPixel(x-1+z, y+1) + GetCurrentPixel(x+z, y+1)*16 + GetCurrentPixel(x+1+z, y+1) + GetLastPixel(x,y)*2)/20)
NouvelleCouleur--; //Attenuation de la flamme
SetPixel(x, y, NouvelleCouleur); //Tracé du pixel
}
}
}

SurfacePrimaire->Unlock(NULL);
SurfaceSecondaire->Unlock(NULL);
}
}

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

/*------------------------------------------------
----------------------------*
| |
| Dessiner des Flammes, Unité d´affichage V.1.0 ( Affichage.h) |
| |
| programmé par Blustuff |
| |

• -------------------------------------------------

---------------------------*/

/*------------------------------------------------
----------------------------*
| Includes |

• -------------------------------------------------

---------------------------*/

1. include <ddraw.h> //Pour l´interface IDirectDraw
2. include <stdlib.h> //Pour random()
3. include <math.h> //Pour sin()

/*------------------------------------------------
----------------------------*
| Propriétés de l´Affichage |

• -------------------------------------------------

---------------------------*/

/*
Les valeurs suivantes doivent corespondre a un mode d´ecran existant et supporté
sinon l´initialisation ne fonctionera pas

• /

/*------------------------------------------------
----------------------------*
| Variables Globales |

• -------------------------------------------------

---------------------------*/

LPDIRECTDRAW7 InterfaceDirectDraw = NULL;
LPDIRECTDRAWSURFACE7 SurfacePrimaire = NULL; //Primary Buffer. En clair, interface représentant la mémore vidéo directement reliée à l´ecran
LPDIRECTDRAWSURFACE7 SurfaceSecondaire = NULL; //Back Buffer. Surface sur laquelle on dessine avant de proceder au bliting ( Je n´epliquerai pas le bliting ici)
LPDIRECTDRAWSURFACE7 SurfaceTexte = NULL; //Surface pour afficher le texte

int* AlignY; //Tableau de valeurs indiquant la taille en octet jusqu´a une ligne de l´ecran

/*------------------------------------------------
----------------------------*
| Fonctions |

• -------------------------------------------------

---------------------------*/

bool InitialiseAffichage(HWND hWnd);
void DesallocationAffichage();
void AfficherTexte(LPDIRECTDRAWSURFACE7 Surface, char* Text, int X, int Y, bool Center = true, DWORD TextColor = 0x00ffffff, DWORD BackColor = 0x00000000);
void EffacerSurface(LPDIRECTDRAWSURFACE7 Surface);
void DessinerFlammes();

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

je l´ai pris sur un site asser complet sur lequel j´ai appris a progammer mis je suis encore loin du niveau des types qui font des trucs comme ca!

balrog666 : Quel rapport avec la 3D ?

Décidemment ca devient une mode ici de copier/coller du code illisible ! Non pas que je remette en doute la clarté du code source d´origine, mais sur ce forum ils ont comme qui dirait . . un peu de mal à garder leur mise en page.

Enfin bref... ca remplit un topic : ) c´est déjà ca

mais quesque je m en fout de ton frere...(mais oui le mien il a pirater microsoft et a détourner 200.000 $.et il l a fait créditer sur son compte en suisse.
en suite il est allé en amérique ( il a 12 ans ) et il a empécher un attentat.et un hold up.

lol...(t inquiete pas y a des gars en blouse blanche qui peuvent te soigner)...

cela dit, je peux comprendre votre enervement apres ce jeune homme.
Ce serait casse couille pour des mecs qui ont fait 4 ans d´etude apres bac de se voir supplanté par un morveux de 3eme tout ca parceque le system educatif actuel plus abouti qu´il y a 5 ans propose des formations accélérées particuliéres dans un domaine précis.
Enfin bon, faudrait deja que ca existe.

Tu sais je crois qu´il y a une chose que les études ne remplaceront jamais ( études accélérées, intensives ou je ne sais quoi d´autre) : l´expérience ! Tu auras beau faire tes études en 1 mois, 6 mois, 1 an, 4 ans, ou toute ta vie. Si tu n´as aucune pratique et qui plus est pendant une formation courte de quelques mois tu en sortiras qu´avec très peu d´exp voire pas du tout . ..
Et ce n´est pas avec ce que l´on t´apprend dans ces études ( même celles dédiées aux jeux vidéo) que tu t´en sortiras dans le monde professionnel, le fossé est et restera toujours présent ( stage ou pas).

mais je vais en avoir de l experience cet été y a une boite de développement qui m embauche un mois.

1 mois ? ; ) mouarf
encore 12 x 1 mois comme ca et tu commenceras a peut être devenir intéressant

Un seul mot a dire : mouhaaaaaaaaaaaa lol