Also, vor allem weg:

- Ich kann C++
- Ich code ein Mod fuer HL
- Und ich will keine super 3D Engine coden, sondern auf dem Boden bleiben

Also mein Prob ist, dass ich == NULL Idee hab wie ich ueberhaupt anfangen sollte ein KLEINES Game zu coden! Es geht jetzt nicht um ein 3D Game oder so, sondern einfach um ein dummes Jump and Run oder nen Textadventure oder so... ich brauch einfach nen kleinen Anschupser um drauf zu kommen, wie man sowas macht.... Also Tutorial zum Einstieg ins Gamecoding! NICHT FUER EINE SPRACHE!

Waer nett wenn ihr mir da ein bisschen helfen koenntet und evtl. mal posten koenntest, mit was fuer Spielen ihr so angefangen seit...

Move In!

VISIT US Move In!

Als ich noch gecodet habe hab ich das ganze so angefangen:
Auf game-net.de Tutorials angeguckt, die exx2d engine runter geladen und einen vertikal-shooter geschrieben...ist ganz einfach. wenn du willst kann ich dir mal den source schicken...obwohl der wahrscheinlich schrecklich aussieht... :-) war nie so der held

Ich will garkeinen Shooter oder so coden... irgendwas stink langweiliges nur um da ueberhaupt mal rein zu kommen....

Move In!

VISIT US Move In!

hmmm... dann mach doch einfach ein textadventure...das ist ja wohl nicht so schwer...
Ansonsten sind Spiele eigentlich ja ganz normale Programme...wenn du ein bisschen C++ kannst sollte das auch nicht soo ein Problem sein. Im Grunde sind die meisten (von der Struktur) her änhlich aufgebaut:
Start des Spiels (Menü, etc.)
Gameschleife (zB. while(key==notEsc)
{
und dann hier denn inhalt
}

ist jetzt nur ganz kurz beschrieben...und ich weiss nicht mal ob der Synthax da oben überhaupt stimmt...ist halt schon lange her :-)

wie ist nochmal der genaue Link?

---------------------------------
www.killerlevels.de Editing mit Quake III Arena, Urban Terror, Elite Force

http://www.games-net.de/resource.php
:)
Hats ganz viel zeugs... auch viele Sourcecodes.

Genau das was NoFL da oben so eben auf die Schnelle gepotet hat, dass wuerde ich gerne ein wenig sehr ausfuehrlicher mit ein par Beispielen oder sowas haben.... jemand ne Idee wo man sowas kriegen kann?

Move In!

VISIT US Move In!

So, ich mach das jetzt nicht gern, da der Code für die meisten wahrscheinlich schrecklich aussieht, und nichtmal alles von mir ist (ist mit dem Beispiel der Exx2d engine geschrieben).... also, bitte nicht hauen. Ich wollte einfach mal etwas proggen, das man spielen kann. Ist nochnichtmal richtig fertig.
:-)
Quellcode:// Beispiel1.cpp : Definiert den Einsprungpunkt für die Anwendung.
//

#include "stdafx.h"
#include "mmsystem.h"
#include <windows.h>
#include <bitset>

#include "exx2dmain.h" //Header Datei zu Exx 2D ohne dieser Datei läuft nichts

#include "player.h"
#include "weapon.h"
#include "monster.h"
#include "explosion.h"
//***** DEFINES *****//

#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define scrw = 1024
#define scrh = 768
//***** GLOBALS *****//
//GAME
Player *Player1;
goliath_a *goliath_a1[10];
int hw_m_ga_alive;
pRocketa *Rocketa1[50];
int hw_m_ra_alive=0;
int nextRocketa1 = 0; //Zum erstellen von Rockets, zum beschleunigen
bool last_r_left = true;
explo1 *explosion1[20];
//SYSTEM
DWORD time,fpsold_time;  //Die Variablen, die notwendig sind für konstante FPS  
DWORD last_r_time;        //    "        "        "    "        "        "    "        Rokets
DWORD last_ex_time;
std::bitset<786432> Pixels; //Fuer Kollisionsabfrage
HWND hWnd;


Painter painter; //Instanz der Exx2D Klasse, die alle Funktionen für die Grafik
                 //zur Verfügung stellt

ScreenInfo screeninfo; //Für die Initialisierung der Klasse painter notwendig
                       //diese Struktur wird mit den Werten für den Bildschirm gefüllt,

PainterFont Schrift; // Um eigenen Text auf den Screen zu bringen gibt es die PainterFont

ParticleSystem PartikelRing,
                PartikelNormal    ; //die explosionen mit Partikeln
                      

pBmpSurface hintergrund, playerBMP, rocketBMP, goliath_aBMP, explo1BMP; /*Für jede .bmp muß ein solches Surface angelegt werden
                            es wird dann in der initialisierung geladen. Die Quelldateien dürfen ruhig
                            mehr als 1 Bild enthalten dürfen aber nicht größer werden, als die
                            eingestellte Bildschirmauflösung des Painter Objektes*/



long PASCAL WinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}

BOOL InitApp(HINSTANCE hInst, int nCmdShow)
{
    WNDCLASS WndClass;

    WndClass.style = CS_HREDRAW | CS_VREDRAW;
    WndClass.lpfnWndProc = WinProc;
    WndClass.cbClsExtra = 0;
    WndClass.cbWndExtra = 0;
    WndClass.hInstance = hInst;
    WndClass.hIcon = LoadIcon(hInst, IDI_APPLICATION);
    WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    WndClass.hbrBackground = NULL;
    WndClass.lpszMenuName = NULL;
    WndClass.lpszClassName = "Window Class";
    RegisterClass(&WndClass);

    hWnd = CreateWindowEx(
        WS_EX_TOPMOST,
        "Window Class",
        "DirectDraw-Test",
        WS_POPUP,
        0,0,
        GetSystemMetrics(SM_CXSCREEN),
        GetSystemMetrics(SM_CYSCREEN),
        NULL,
        NULL,
        hInst,
        NULL);

    if(!hWnd) return FALSE;

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);


    //Hier wird nun die painter instanz initialisiert
    //Als erstes screeninfo mit Werten füllen und dann an die Initialisierung von painter übergeben
    screeninfo.BitDepth=32;   //Farbtiefe 16 bit
    screeninfo.ScreenHeight=768; //Höhe des Bildschirms 480
    screeninfo.ScreenWidth=1024;  //Breite 640
    //Dann DirectDraw Objekt erstellen
    painter.CreatePainter(hWnd,screeninfo,"palette.bmp");


    //Hintergrundbild laden mit belibiger Tranzparenz
    if(!hintergrund.CreatepBmpSurface(&painter,"test.bmp",23,0,0))
        MessageBox(hWnd,"Fehler beim Laden des Hintergrundes!","Meldung",MB_OK);

    //Player-bild laden mit belibiger Tranzparenz
    if(!playerBMP.CreatepBmpSurface(&painter,"player.bmp",0,0,0))
        MessageBox(hWnd,"Fehler beim Laden des Playerbildes!","Meldung",MB_OK);

        //Rocket-bild laden mit belibiger Tranzparenz
    if(!rocketBMP.CreatepBmpSurface(&painter,"rakete01.bmp",0,0,0))
        MessageBox(hWnd,"Fehler beim Laden des Rocketbildes!","Meldung",MB_OK);

    //goliath_a-bild laden mit belibiger Tranzparenz
    if(!goliath_aBMP.CreatepBmpSurface(&painter,"goliath_a.bmp",0,0,0))
        MessageBox(hWnd,"Fehler beim Laden des goliath_abildes!","Meldung",MB_OK);
    
    //explo1-bild laden mit belibiger Tranzparenz
    if(!explo1BMP.CreatepBmpSurface(&painter,"explo1.bmp",0,0,0))
        MessageBox(hWnd,"Fehler beim Laden des explo1bildes!","Meldung",MB_OK);

    //Schrift mit der Höhe und Breite 15 mit 10 Zeichen in einer Reihe(alles im Bitmap festgelegt)
    //und der Tranzparenzfarbe Schwarz
    Schrift.CreateFont(&painter,"schrift.bmp",15,15,10,0,0,0);
    
    //init. der Game Entities
    Player1 = new Player(100,10,10, 500, 400);
    for(int i=0; i<50; i++)
    {
        Rocketa1[i] = new pRocketa(2000,3000);
    }
    for(int l=0; l<10; l++)
    {
        goliath_a1[l] = new goliath_a(3000,2000);
    }
    
    for(int zin=0; zin<20; zin++)
    {
        explosion1[zin] = new explo1(0,0);
    }
    time=timeGetTime();
    fpsold_time=time;
    last_r_time=time+500;
    last_ex_time=time+10;

return TRUE;

}


//Dies ist der Hauptteil der Anwendung

int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
    MSG msg;

    if(!InitApp(hInst, nCmdShow)) return FALSE;
    

    while(!KEY_DOWN(VK_ESCAPE))
    {    

        if(PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
        {
            if(!GetMessage(&msg, NULL, 0, 0 )) return msg.wParam;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {    
            
        time=timeGetTime();      
        if (time>fpsold_time+10)    //FPS = 100
        {
  
            
        // An dieser Stelle kommt der Code rein, der so oft es geht wiederholt wird
            //(Game Schleife)

            //Prä-Kollisionsabfrage für Player
            for(int z=0; z<10;z++)
                {
                    if((Player1->PosX<=goliath_a1[z]->PosX&&goliath_a1[z]->PosX<Player1->PosX+75||
                        Player1->PosX<=goliath_a1[z]->PosX+59&&goliath_a1[z]->PosX+59<Player1->PosX+75)
                        &&
                        (Player1->PosY<=goliath_a1[z]->PosY&&goliath_a1[z]->PosY<Player1->PosY+79||
                        Player1->PosY<=goliath_a1[z]->PosY+79&&goliath_a1[z]->PosY+79<Player1->PosY+60))
                    {
                        Player1->PraeKollision = true;
                        goliath_a1[z]->PraeKollision =true;
                    }
                }
            
            //Prä-Kollisionsabfrage für Rocketa
            for(int zg=0; zg<10; zg++)
                {
                    for(int zr=0; zr<=49;zr++)
                    {
                        if((goliath_a1[zg]->PosX<=Rocketa1[zr]->PosX&&Rocketa1[zr]->PosX<goliath_a1[zg]->PosX+59||
                            goliath_a1[zg]->PosX<=Rocketa1[zr]->PosX+12&&Rocketa1[zr]->PosX+12<goliath_a1[zg]->PosX+59)
                            &&
                            (goliath_a1[zg]->PosY<=Rocketa1[zr]->PosY&&Rocketa1[zr]->PosY<goliath_a1[zg]->PosY+79||
                            goliath_a1[zg]->PosY<=Rocketa1[zr]->PosY+30&&Rocketa1[zr]->PosY+30<goliath_a1[zg]->PosY+79))
                        {

                            //explosion aussuchen
                            int zexs=0;
                            bool gefunden=false;
                            while(zexs<20&&!gefunden)
                            {
                                if(explosion1[zexs]->activ == false)
                                {
                                    explosion1[zexs]->activ = true;
                                    explosion1[zexs]->PosX = goliath_a1[zg]->PosX;
                                    explosion1[zexs]->PosY = goliath_a1[zg]->PosY;
                                    gefunden = true;
                                }
                                zexs++;
                            }
                        
                            goliath_a1[zg]->alive =false;
                            goliath_a1[zg]->PosY = 4000;
                            Rocketa1[zr]->activ = false;
                            Rocketa1[zr]->PosY = 2000;
                            hw_m_ga_alive--;
                        }
                    }
                }
            //bewegen des Players
            if(KEY_DOWN(VK_UP))
            {
                if(Player1->PraeKollision)
                {
                }
                else
                {
                Player1->move(2);
                }
            }
            
            if(KEY_DOWN(VK_DOWN))
            {
                Player1->move(3);
            }
            
            if(KEY_DOWN(VK_LEFT))
            {
                Player1->move(0);
            }

            if(KEY_DOWN(VK_RIGHT))
            {
                Player1->move(1);
            }
            
            //Rakete feuern
            if(time>last_r_time+500)
            {
            if(KEY_DOWN(VK_SPACE))
            {
                if (!Rocketa1[nextRocketa1]->activ)
                {
                    if(!last_r_left)
                    {
                        Rocketa1[nextRocketa1]->activ = true;
                        Rocketa1[nextRocketa1]->PosX = Player1->PosX+10;
                        Rocketa1[nextRocketa1]->PosY = Player1->PosY-15;
                        nextRocketa1++;
                        last_r_left = true;
                        last_r_time=timeGetTime();
                    }
                    else
                    {
                        Rocketa1[nextRocketa1]->activ = true;
                        Rocketa1[nextRocketa1]->PosX = Player1->PosX+52;
                        Rocketa1[nextRocketa1]->PosY = Player1->PosY-15;
                        nextRocketa1++;
                        last_r_left=false;
                        last_r_time=timeGetTime();
                    }
                    
                    if(nextRocketa1>49)
                    {
                    nextRocketa1 = 0;
                    }
            
                }
            }
            }
            
            //Raketen bewegen
            for (int j=0; j<50; j++)
            {
                if(Rocketa1[j]->activ)
                {
                    
                    if(Rocketa1[j]->livetime<8)
                    {
                        Rocketa1[j]->PosY=Rocketa1[j]->PosY-Rocketa1[j]->livetime+3;
                        Rocketa1[j]->livetime++;
                    }
                    
                    else
                    {
                        Rocketa1[j]->PosY=Rocketa1[j]->PosY-8;
                    }

                }
                //unsichtbare Raketen zerstören
                if(Rocketa1[j]->PosY<0)
                {
                    Rocketa1[j]->activ = false;
                }

}

text war zu lang:
Quellcode:
            }

            // Gegner erstellen
            if(rand()%50 == 3)
            {
                int i=0;
                bool gefunden=false;
                while(i<10&&!gefunden)
                {
            
                    if(goliath_a1[i]->alive==false)
                    {
                        goliath_a1[i]->alive = true;
                        goliath_a1[i]->PosX = rand()%966;
                        goliath_a1[i]->PosY = -80 -rand()%900;
                        hw_m_ga_alive++;
                        gefunden=true;
                    }
                    i++;
                }
            }
            
            //Gegner bewegen
            if(Player1->alive)
            {
                bool gefunden = false;
                int i=0;
                while(i<10)
                {
                    if(goliath_a1[i]->alive&&!goliath_a1[i]->PraeKollision)
                    {
                        goliath_a1[i]->PosY=goliath_a1[i]->PosY+goliath_a1[i]->Geschwindigkeit;
                    }
                    i++;
                }
                
                for(int m=0; m<10; m++)
                {
                    //unsichtbare Gegner zerstören
                    if(goliath_a1[m]->PosY>768)
                    {
                        goliath_a1[m]->alive = false;
                        //hw_m_ga_alive--;
                    }
                }

            }
            
            //Jetzt wird die Struktur auf das Surface gebracht
            painter.Draw(hintergrund.DDrawSurface,0,0,640,480,1024,768,0,0,0,1,true);
                            

            //Einen kurzen Text ausgeben, die Ausgabegröße ist beliebig
            Schrift.TextOut("SpaceRider 0.010", //Der Text der ausgegeben werden soll
                            40,0,   //Die Position des Textes auf dem Bildschirm(in Pixeln)
                            10,10   //Die Höhe/Breite in Pixeln
                            );
            
            //Rockets zeichnen
            for(int i=0; i<50; i++)
            {
                if(Rocketa1[i]->activ)
                {
                    painter.Draw(rocketBMP.DDrawSurface,Rocketa1[i]->PosX,Rocketa1[i]->PosY,24,59,12,30,0,0,0,1,true);
                }
            }
            
            //Gegner zeichnen
            for(int l=0; l<10; l++)
            {
                if(goliath_a1[l]->alive)
                {
                    painter.Draw(goliath_aBMP.DDrawSurface,goliath_a1[l]->PosX,goliath_a1[l]->PosY,59,79,59,79,0,0,0,1,true);
                }
            }
            
            //Player zeichnen
            painter.Draw(playerBMP.DDrawSurface,Player1->PosX,Player1->PosY,100,79,75,60,0,0,0,1,true);
            
            //Explosionen zeichnen
            if(time>last_ex_time +5)
            {
            for(int zexz=0; zexz<20; zexz++)
            {
                if(explosion1[zexz]->activ)
                {
                    switch(explosion1[zexz]->frame)
                    {
                    case 0:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,0,0,1,true);
                        break;

                    case 2:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,0,0,1,true);
                        break;

                    case 4:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,0,0,1,true);
                        break;
                    
                    case 6:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,0,0,1,true);
                        break;
                    
                    case 8:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,0,0,1,true);
                        break;

                    case 10:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,75,0,1,true);
                        break;

                    case 12:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,75,0,1,true);
                        break;

                    case 14:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,75,0,1,true);
                        break;

                    case 16:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,75,0,1,true);
                        break;

                    case 18:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,75,0,1,true);
                        break;

                    case 20:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,150,0,1,true);
                        break;

                    case 22:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,150,0,1,true);
                        break;

                    case 24:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,150,0,1,true);
                        break;

                    case 26:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,150,0,1,true);
                        break;

                    case 28:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,150,0,1,true);
                        break;

                    case 30:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,225,0,1,true);
                        break;

                    case 32:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,225,0,1,true);
                        break;

                    case 34:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,225,0,1,true);
                        break;

                    case 36:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,225,0,1,true);
                        break;

                    case 38:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,225,0,1,true);
                        break;
                    
                    case 1:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,0,0,1,true);
                        break;

                    case 3:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,0,0,1,true);
                        break;

                    case 5:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,0,0,1,true);
                        break;
                    
                    case 7:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,0,0,1,true);
                        break;
                    
                    case 9:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,0,0,1,true);
                        break;

                    case 11:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,75,0,1,true);
                        break;

                    case 13:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,75,0,1,true);
                        break;

                    case 15:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,75,0,1,true);
                        break;

                    case 17:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,75,0,1,true);
                        break;

                    case 19:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,75,0,1,true);
                        break;

                    case 21:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,150,0,1,true);
                        break;

                    case 23:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,150,0,1,true);
                        break;

                    case 25:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,150,0,1,true);
                        break;

                    case 27:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,150,0,1,true);
                        break;

                    case 29:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,150,0,1,true);
                        break;

                    case 31:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,0,225,0,1,true);
                        break;

                    case 33:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,75,225,0,1,true);
                        break;

                    case 35:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,150,225,0,1,true);
                        break;

                    case 37:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,225,225,0,1,true);
                        break;

                    case 39:
                        painter.Draw(explo1BMP.DDrawSurface,explosion1[zexz]->PosX,explosion1[zexz]->PosY,75,75,75,75,300,225,0,1,true);
                        break;


                    }
                last_ex_time = timeGetTime();
                explosion1[zexz]->frame++;
                if (explosion1[zexz]->frame > 39)
                {
                    explosion1[zexz]->activ = false;
                    explosion1[zexz]->frame = 0;
                }

                }
            }
            }
            //Nun wird das Surface auf dem Bildschirm ausgegeben
            painter.Flip();
            
            Player1->PraeKollision = false;
            for(int zPKL=0; zPKL<10; zPKL++)
            {
                goliath_a1[zPKL]->PraeKollision = false;
            }
            fpsold_time=time;
        }
        }                
    }

    PostMessage(hWnd, WM_CLOSE, 0, 0);

    return(msg.wParam);


Meiner Lebensaufgabe, alle Programmierer von Plattformabhängigkeit loszureißen, entsprechend muß ich jetzt u.a. auf SDL ( http://www.libsdl.org/ ) hinweisen, und auf http://thewall.de/coding/ gibt's ja auch Tutorials dazu ;p

Ansonsten kann man natürlich immer mit Textadventures anfangen, da braucht man nur printf() & co. dazu... (Jump'n'Run geht damit aber schon nicht mehr so gut ;))

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

ich hab vor Jahren mal was in Assembler geproggt, ein Jump´nRun. Ohne irgendwelche Engine, direkt die VGA vergewaltigt, alles Handarbeit. Es geht also. (Ist halt nur 320x200x256C)
Nur so als Anregung: Runen.zip(1.2MB)
p.s. zur Steuerung den Ziffernblock benutzen

Sig as a brick ┴┬┴┬┴┬┴┬┴┬┴┬┴
WW

@Prefect: Ich war jung und brauchte das Geld! oder so in der Art...aufjedenfall wars für mich damals schon recht cool das ich sowas geschafft habe :-) Bei der Pixelgenauen Kollisionsabfrage bin ich dann aber stecken geblieben und seither mache ich eigentlich nichts mehr mit C++ (ja, ich weiss, das zeugt von einem unglaublichen Durchhaltungsvermögen...) ;-)

Ich hoffe ich konnte dir trotzdem helfen Mexil.

Wow.....
Der Prince of Persia Klon ist echt geil!
Und das hast du wirklich komplett in ASM programmiert?
Nicht schlecht....

BattleTech-MOD:
http://bthl.unitedgaming.net/

tja, war auch ne Sauarbeit, würd ich heute nicht mehr machen (muss man ja auch nicht) aber damals sollte es auch noch auf nem 286er flüssig laufen und da ist ASM halt erste Sahne.
Ach ja, hier die Levelcodes zum reinschnuppern..
2408
A1E7
FEDE
A239
8146
CABA
2309

Sig as a brick ┴┬┴┬┴┬┴┬┴┬┴┬┴
WW

nochmal zu mexil(beispiel jump&run):
-du könntest den bildschirm in erstmal klötze einteilen(32²oder so), dann die klötze erstmal mit einem bildchen versehen und dann aus einer datei ein level asulesen(also quasi wie dein eigenes bildformat nur mit klötzchen statt pixeln).
-schwieriger wird jetzt mit deinem männlein und der kolisionsabfrage.
-für den anfang sollte es reichen die figur, immer wenn sie in einem stein steckt einfach rauszuschieben, also je nachdem y.pos erhöhen oder verringer.

das klingt jetzt etwas verwirrend, aber wenn du erstmal angefangen hast geht alles von alleine.
wenn du noch wenig erfahrung hast kannst du erstmal immer kleine beispiel(übungs)teile programmieren die du später zusammen stetzt.

solche grafik bibliotheken wie du sie oben findest können wirklich sehr nützlich sein und die tuts die oft dabei sind haben mir immer sehr geholfen(oder helfen mir noch immer).

auch wenns in manchen augen nichtmehr ganz zeitgemäß ist, solltest du vielleicht für dos anfangen.

ich hoffe das konnte dir wenigstens ein bischen helfen.

bye jo