JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=28f8c3b6a1d2ab1ea16ebfa417bebc24Medaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

flags Probleme
Gehe zu Seite 1, 2  Weiter
 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 00:56    Titel: flags Probleme Antworten mit Zitat

Hallo leute,

Ach so meine angeben ich:
CPU AMD Athlon XP 2000+
Arbeitspeicher 768 DDRRAM
Grafikkarte: 6600GT von XFX
Ich nutze DDraw und LPDIRECTDRAW7 aber Chris SDK vom Buch, gibs da denn irgend welche Fehler?
Und nutzen tue ich Visual C++ 2005

Ich habe Probleme mit ein Flags und noch mit was anderem, aber erst mal will ich den flags weg kriegen.

Das ist der Fehler "error C2065: 'flags' : undeclared identifier"

Und hier der Code
zu den ganzen
CPP:
int Create_BOB(BITMAP_OBJ_PTR bob,    // Den Bob erschafen
            int width, int height, // Größe des Bobs
            int attr,              // attrs
            int falgs = 0)         // memory falg
{
   // Schaffen Sie den Gegenstand von BOB, bemerken Sie,
   // dass alles sich AUF UND AB BEWEGT, werden als offscreen
   // Oberflächen in VRAM als der Verzug geschaffen, wenn Sie
   // System-Gedächtnis dann DDSCAPS_SYSTEMMEMORY gleiche
   // Satz-Fahnen verwenden wollen

   DDSURFACEDESC2 ddsd; // Verwendet, um Oberfläche zu schaffen

   // Satz-Zustand und Attribute von BOB
   bob->state = BOB_STATE_ALIVE;
   bob->attr  = attr;
   bob->image = NULL;

   // Satz-Position und Geschwindigkeit zu 0
   bob->x = bob->y = bob->xv = bob->yv = 0;

   // Satz, um auf Kappen, Breite, und Höhe zuzugreifen
   memset(&ddsd,0,sizeof(ddsd));
   ddsd.dwSize =  sizeof(ddsd);
   ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;

   // Setz-Dimensionen der neuen bitmap Oberfläche
   ddsd.dwWidth = bob->width = width;
   ddsd.dwHeight = bob->height = height;

   // Setz-Oberfläche zur offscreen Ebene
   --> ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | flags; <-- Das ist der Fehler den er mir zeigt

   // Create the Surface
   if (lpdd->CreateSurface(&ddsd,&(bob->image),NULL)!=DD_OK)
      return(0);

   // Setz-Farbenschlüssel, sich 0 zu färben
   DDCOLORKEY color_key; // Verwendet, um Farbenschlüssel zu setzen
   color_key.dwColorSpaceLowValue  = 0;
   color_key.dwColorSpaceHighValue = 0;

   // Setzen Sie jetzt den Farbenschlüssel für die Quelle blitting
   (bob->image)->SetColorKey(DDCKEY_SRCBLT, &color_key);

   // retunr success
   return(1);
} // end Create_BOB


Und denn habe ich Probleme mit dem WPARAM er sagt mir immer das ich Datenverluste habe wie kriege ich das weg?
Fehler warning C4244: 'return' : conversion from 'WPARAM' to 'int', possible loss of data
Und hier der Code.
CPP:
WINAPI WinMain( HINSTANCE hinstance,
                HINSTANCE hprevinstance,
               LPSTR lpcmdline,
               int ncmdshow)

{
   WNDCLASS winclass; // nimmt die von uns erzeugte Klasse auf
   HWND         hwnd; // generischer Fenster-Handle
   MSG           msg; // generische Nachricht
   HDC           hdc; // generische DC
   PAINTSTRUCT    ps; // generische Paintstruct

   // Fensterklassenstruktur füllen
   winclass.style              = CS_DBLCLKS | CS_OWNDC |
                                CS_HREDRAW | CS_VREDRAW;
   winclass.lpfnWndProc        = WindowProc;
   winclass.cbClsExtra         = 0;
   winclass.cbWndExtra         = 0;
   winclass.hInstance          = hinstance;
   winclass.hIcon              = LoadIcon(NULL, IDI_APPLICATION);
   winclass.hCursor            = LoadCursor(NULL, IDC_ARROW);
   winclass.hbrBackground      = (HBRUSH)GetStockObject(BLACK_BRUSH);
   winclass.lpszMenuName       = NULL;
   winclass.lpszClassName      = WINDOW_CLASS_NAME;

   // Fensterklasse registrieren
   if (!RegisterClass(&winclass))
      return(0);

   // Fenster erstellen
   if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME,      // Klasse
                            "WinX Game Console",    // Titel
                       WS_POPUP | WS_VISIBLE, 
                       0,0,                    // x,y
                       WINDOW_WIDTH,           // Breite
                       WINDOW_HEIGHT,          // Höhe
                       NULL,                   // Handle f. übergeord. Fenster
                       NULL,                   // Handle für Menü
                       hinstance,              // Instanz
                       NULL)))                 // Parameter für Erstellung

return(0);
// hide The Mouse
ShowCursor(FALSE);
// Fenster-Handle in einer globalen Variablen speichern
main_window_handle = hwnd;
main_instance      = hinstance;

// Alle für doe Spielekonsole spezifischen Initialisierungen vornehmen
Game_Init();
// Eintritt in die Hauptereignisschleife
while(1)
{
   if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
   {
      // Prüfen, ob beendet werden soll
      if (msg.message == WM_QUIT)
         break;

      // Tastenkürzel übersetzen
      TranslateMessage(&msg);
      // Nachricht an die Fensterprozedur senden
      DispatchMessage(&msg);
   } // end if
   // Hier beginnt die Hauptverarbeitung für das Spiel
   Game_Main();
} // end while
// Spiel beenden und Ressurcen freigeben
Game_Shutdown();
// Zurück zu Windows
--> return(msg.wParam); <-- Der Fehler
} // end WinMain

Würde sehr nett sein wenn ihr mir helfen könntet und wenn ich was vergessen habe ein COde reinzuschreiben denn sagt mir bitte bescheit und ich setzte ihn denn rein.

mfg
Patrick L.

P.s Irgend wie habe ich immer mit dem WPARAM Probleme.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
Christian Rousselle
Site Admin


Alter: 48
Anmeldedatum: 19.07.2002
Beiträge: 1630

Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 08:56    Titel: Antworten mit Zitat

Tippfehler: falgs (direkt im Funktionskopf)
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 11:04    Titel: Antworten mit Zitat

Christian Rousselle hat Folgendes geschrieben:
Tippfehler: falgs (direkt im Funktionskopf)


Ich danke dir Christian. ist ma ja peinlich Embarassed das ich es nicht selber finde den fehler
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 11:16    Titel: Antworten mit Zitat

Löst man ein fehler kommen gleich nächste ist das immer so?????

Jetzte ist sohn fehler gekommen:

error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
So wie ich das übersetz habe mit mein schlechtes englich, das er irgend was vermisst in der int. Habe ich det richtig übersetz?

Okay den Fehler habe ich gelöst.

Was meint er einglich mit
d:\Eigene Dateien\Projekte\BOB1\Main.cpp(524): warning C4101: 'ps': Unreferenzierte lokale Variable <-- das genau fürn leihen erklärt
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
Kampfhund
Super JLI'ler


Alter: 42
Anmeldedatum: 20.07.2002
Beiträge: 408

Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 13:10    Titel: Antworten mit Zitat

City Hunter hat Folgendes geschrieben:

Was meint er einglich mit
d:\Eigene Dateien\Projekte\BOB1\Main.cpp(524): warning C4101: 'ps': Unreferenzierte lokale Variable <-- das genau fürn leihen erklärt


Soweit ich weis, bedeutet das nur, dass du eine Variable deklariert hast, sie aber nicht benutzt. Beim Überfliegen konnte ich im Quellcode auch keine Stelle finden an der du ps verwendest.

PS: Bitte verwende cpp anstatt code Tags. Das ist übersichtlicher. Ich habe die code Tags mal in deinem Post angepasst.
_________________
Kochen ist ein NP-schweres Optimierungsproblem.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 13:17    Titel: Antworten mit Zitat

Kampfhund hat Folgendes geschrieben:
City Hunter hat Folgendes geschrieben:

Was meint er einglich mit
d:\Eigene Dateien\Projekte\BOB1\Main.cpp(524): warning C4101: 'ps': Unreferenzierte lokale Variable <-- das genau fürn leihen erklärt


Soweit ich weis, bedeutet das nur, dass du eine Variable deklariert hast, sie aber nicht benutzt. Beim Überfliegen konnte ich im Quellcode auch keine Stelle finden an der du ps verwendest.

PS: Bitte verwende cpp anstatt code Tags. Das ist übersichtlicher. Ich habe die code Tags mal in deinem Post angepasst.


Soll ich mal den ganzen Code reinsetzten?
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 13:19    Titel: Antworten mit Zitat

So hier mal der ganze Code

Und hier noch mal wo er ist mit zeilen vor.
http://rafb.net/paste/results/d0hTWX36.html

CPP:
// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN
#define INITGUID

#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>

#include <ddraw.h>  // directX Includes

// DEFINES //////////////////////////////////////////////////

// defines for windows
#define WINDOW_CLASS_NAME "WINXCLASS"  // Klassen Name

#define WINDOW_WIDTH  800              // Größe des Fensters
#define WINDOW_HEIGHT 600
#define SCREEN_WIDTH  800              // Größe des Bild
#define SCREEN_HEIGHT 600
#define SCREEN_BPP    8                // Bit pro pixel

#define BITMAP_ID     0x4D42           // Universall ID des Bitmap

// define des BOBs
#define BOB_STATE_DEAD    0      // Das ist ein Toter Bob
#define BOB_STATE_ALIVE   1      // Das ist ein Lebner Bob
#define BOB_STATE_LOADED  2      // Das Bob wurde geladen

// defines von Asteroiden
#define NUM_ASTEROIDS     64     // Anzahl der Aktiven Asteroiden

// MACROS //////////////////////////////////////////////////////

// these read the keyboard asynchronously
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// Das ist ein 16 bit Farben value in format 5.5.5 (1-bit alpha mode)
#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

// Das ist ein 16 bit Farben value in format 5.6.5 ( green dominate mode)
#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

// TYPES /////////////////////////////////////////////////////////

typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// Kontainer Struktur des bitmaps .BMP file
typedef struct BITMAP_FILE_TAG
{
   BITMAPFILEHEADER bitmapfileheader;   // Das Bitmapfile Header
   BITMAPINFOHEADER bitmapinfoheader;   // Dies ist der info including der Palette
   PALETTEENTRY     palette[256];       // Wir speichern die Palette hier
   UCHAR            *buffer;            // Dies ist ein Zeiger auf den Daten

} BITMAP_FILE, *BITMAP_FILE_PTR;

// die blitter Gegenstandstruktur BOB
typedef struct BITMAP_OBJ_TYP
{
   int state; // der Zustand des Gegenstandes (allgemein)
   int attr;  // Attribute, die den Gegenstand betreffen (allgemein)
   int x,y;   // Position fuer das Bitmap aufen Schirm
   int xv,yv; // Geschwindigkeit des Gegenstandes
   int width, height; // die Breite und die Höhe des Bitmap
   LPDIRECTDRAWSURFACE7 image; // die Bit-Übersichtsoberfläche selbst

} BITMAP_OBJ, *BITMAP_OBJ_PTR;

// PROTOTYPES //////////////////////////////////////////////

// game Konsole
int Game_Init(void *parms=NULL);
int Game_Shutdown(void *parms=NULL);
int Game_Main(void *parms=NULL);

// bitmaps
int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename);
int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap);
int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height);

// bobs
int Draw_BOB(BITMAP_OBJ_PTR bob,LPDIRECTDRAWSURFACE7 dest);
int Destroy_BOB(BITMAP_OBJ_PTR bob);
int Create_BOB(BITMAP_OBJ_PTR bob,int width, int height,int attr, int flags);
int Load_BOB(BITMAP_OBJ_PTR bob,BITMAP_FILE_PTR bitmap,int cx,int cy,int mode);

// GLOBALS ///////////////////////////////////////////////////

HWND main_window_handle = NULL; // Speichern des Fester handle
HINSTANCE main_instance = NULL; // Speichern des Instance
char buffer[80];                // verwendete, Text zu drucken

LPDIRECTDRAW7        lpdd         = NULL;    // dd Objekt
LPDIRECTDRAWSURFACE7 lpddsprimary = NULL;    // dd primary surface
LPDIRECTDRAWSURFACE7 lpddsback    = NULL;    // dd back surface
LPDIRECTDRAWPALETTE  lpddpal      = NULL;    // ein Zeiger zur hergestellten DDPALETTE
PALETTEENTRY         palette[256];           // Farb Palette
DDSURFACEDESC2       ddsd;                   // ein Direct Draw Oberflächen Beschreibung
DDBLTFX              ddbltfx;                // used to fill
DDSCAPS2             ddscaps;                // eine Direct Drawoberflaeche Fähigkeiten
HRESULT              ddrval;                 // Resultat Rückseite von den DDANRUFEN
UCHAR                *primary_buffer = NULL; // primary Video buffer
UCHAR                *back_buffer    = NULL; // Sekundärer Backbuffer
BITMAP_FILE          bitmap16bit,            // ein 16 bit Bitmap Datei
                     bitmap8bit;             // ein 8 bit Bitmap Datei

BITMAP_OBJ           asteroids[NUM_ASTEROIDS]; // asteroid Field

// FUNKTIONS //////////////////////////////////////////////

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
{
   // Diese Funktion Oeffnet ein Bitmap Datei und ladet das Datei into Bitmap

   int file_handle,  // Die Datei handle
      index;        // looping index

   UCHAR *temp_buffer = NULL; // verwendete, 24 Bitbilder in Bit 16 umzuwandeln
   OFSTRUCT file_data;        // Die File Data information

   // Oeffnen des File if it exists
   if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
      return(0);

   // laden Sie jetzt die Bitmap datei
   _lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

   // prüfen Sie, wenn dieses eine Bitmap datei ist
   if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
   {
      // Schliesen der Datei
      _lclose(file_handle);

      // return error
      return(0);
   } // end if

   // Jetzt wissen wir, daß dieses eine Bitübersicht ist, also innen alle Abschnitte lesen Sie

   // zuerst das Bit-Übersichtsinfoheader

   // laden Sie jetzt die Bit-Übersichtsakte Überschrift
   _lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

   // laden Sie jetzt die Farbe Palette, wenn es Eine gibt
   if(bitmap->bitmapinfoheader.biBitCount == 8)
   {
      _lread(file_handle, &bitmap->palette,256*sizeof(PALETTEENTRY));

      // stellen Sie jetzt alle Markierungsfahnen in der Palette richtig ein und regeln Sie aufgehoben
      // BGR RGBQUAD Datenformat
      for(index=0; index < 256; index++)
      {
         // heben Sie das Rote auf und grün fängt auf
         int temp_color = bitmap->palette[index].peRed;
          bitmap->palette[index].peRed  = bitmap->palette[index].peBlue;
         bitmap->palette[index].peBlue = temp_color;

         // stellen Sie immer das Markierungsfahnen Wort auf dieses ein
         bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
      }// end for index
   } // end if

// Schließlich die Bilddaten selbst
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// Lesen Sie jetzt im Image,
// wenn das Image 8 oder 16 Bit ist,
// dann einfach liest es,
// aber wenn seine 24 Bit es dann in ein vorläufiges Gebiet lesen
// und es dann zu einem 16-Bit-Image umwandeln

if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16)
{
   // Zuteileung des Image
   if(!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
   {
      // Schliessen des File
      _lclose(file_handle);

      // return error
      return(0);
   } // end if

   //  Lesen Sie es jetzt darin
   _lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);
} // end if
else
{
    // Das muss ein 24-Bit-Image sein, es darin laden und es zu 16 Bit umwandeln
   // printf("\nconverting 24 bit image...");

   //    Teilen Sie vorläufigen Puffer zu
   if(!(temp_buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
   {
      // Schliessen des File
      _lclose(file_handle);

      // return error
      return(0);
   } // end if

   // Teilen Sie End-16-Bit-Lagerungspuffer zu
   if(!(bitmap->buffer=(UCHAR *)malloc(2*bitmap->bitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight)))
   {
      // Schliessen des File
      _lclose(file_handle);

      // return error
      return(0);
   } // end if

   //  Lesen Sie es jetzt darin
   _lread(file_handle,temp_buffer,bitmap->bitmapinfoheader.biSizeImage);

   // Wandeln Sie jetzt jeden RGB 24-Bit-Wert in einen 16-Bit-Wert um
   for (index=0; index<bitmap->bitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight; index++)
   {
      // Extrakt RGB Bestandteile (bemerken, dass sie im Gedächtnis BGR sind),
      // auch, nehmen Sie 5.6.5 Format so die Skala passend an
      UCHAR red   = (temp_buffer[index*3 + 2] >> 3), // 5 bits
           green = (temp_buffer[index*3 + 1] >> 2), // 6 bits, change to 3 for 5 bits
            blue  = (temp_buffer[index*3 + 0] >> 3); // 5 bits

      // Entwickeln Sie sich 16-Bit-Farbenwort nehmen 5.6.5 Format an
      USHORT color = _RGB16BIT565(red,green,blue);

      // Schreiben Sie Farbe dem Puffer
      ((USHORT *)bitmap->buffer)[index] = color;
   } // end for index
   
   // Schreiben Sie schließlich die richtige Zahl von Bit aus
   bitmap->bitmapinfoheader.biBitCount=16;
} // end if

#if 0
//  Schreiben Sie das Dateiinfo aus
printf("\nfilnename:%s \nsize=%d \nwidth=%d \nheight=%d \nbitsperpixel=%d \ncolors=%d \nimpcolors=%d",
      bitmap->bitmapinfoheader.biSizeImage,
      bitmap->bitmapinfoheader.biWidth,
      bitmap->bitmapinfoheader.biHeight,
      bitmap->bitmapinfoheader.biBitCount,
      bitmap->bitmapinfoheader.biClrUsed,
      bitmap->bitmapinfoheader.biClrImportant);
#endif

// schliessen des file
_lclose(file_handle);

// Schnipsen Sie den bitmap
Flip_Bitmap(bitmap->buffer,
         bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8),
         bitmap->bitmapinfoheader.biHeight);

// return succes
return(1);

} // end Load_Bitmap_Flie

//////////////////////////////////////////////////////////////////

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
{
   // Diese Funktion veröffentlicht das ganze Gedächtnis vereinigt mit "bitmap"
   if(bitmap->buffer)
   {
      // release memory
      free(bitmap->buffer);

      // reset pointer
      bitmap->buffer = NULL;
   } // end if

   // return seucce
   return(1);
} // end Unload_Bitmap_File

/////////////////////////////////////////////////////////////////////

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
{
   // Diese Funktion wird verwendet, um umgekehrt .BMP Images zu schnipsen

   UCHAR *buffer; // Verwendet, um die Bildverarbeitung durchzuführen
   int index;     // looping index

   // Teilen Sie den vorläufigen Puffer zu
   if(!(buffer = (UCHAR *)malloc(bytes_per_line*height)))
      return(0);

   // Kopiere-Image zum Arbeitsbereich
   memcpy(buffer,image,bytes_per_line*height);

   // flip vertically
   for (index=0; index < height; index++)
      memcpy(&image[((height-1) - index)*bytes_per_line],
             &buffer[index*bytes_per_line], bytes_per_line);

   // release The Memory
   free(buffer);

   // return seucce
   return(1);
} // end Flip_Bitmap

/////////////////////////////////////////////////////////////////////////////

int Create_BOB(BITMAP_OBJ_PTR bob,    // Den Bob erschafen
            int width, int height, // Größe des Bobs
            int attr,              // attrs
            int flags = 0)         // memory falg
{
   // Schaffen Sie den Gegenstand von BOB, bemerken Sie,
   // dass alles sich AUF UND AB BEWEGT, werden als offscreen
   // Oberflächen in VRAM als der Verzug geschaffen, wenn Sie
   // System-Gedächtnis dann DDSCAPS_SYSTEMMEMORY gleiche
   // Satz-Fahnen verwenden wollen

   DDSURFACEDESC2 ddsd; // Verwendet, um Oberfläche zu schaffen

   // Satz-Zustand und Attribute von BOB
   bob->state = BOB_STATE_ALIVE;
   bob->attr  = attr;
   bob->image = NULL;

   // Satz-Position und Geschwindigkeit zu 0
   bob->x = bob->y = bob->xv = bob->yv = 0;

   // Satz, um auf Kappen, Breite, und Höhe zuzugreifen
   memset(&ddsd,0,sizeof(ddsd));
   ddsd.dwSize =  sizeof(ddsd);
   ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;

   // Setz-Dimensionen der neuen bitmap Oberfläche
   ddsd.dwWidth = bob->width = width;
   ddsd.dwHeight = bob->height = height;

   // Setz-Oberfläche zur offscreen Ebene
   ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | flags;

   // Create the Surface
   if (lpdd->CreateSurface(&ddsd,&(bob->image),NULL)!=DD_OK)
      return(0);

   // Setz-Farbenschlüssel, sich 0 zu färben
   DDCOLORKEY color_key; // Verwendet, um Farbenschlüssel zu setzen
   color_key.dwColorSpaceLowValue  = 0;
   color_key.dwColorSpaceHighValue = 0;

   // Setzen Sie jetzt den Farbenschlüssel für die Quelle blitting
   (bob->image)->SetColorKey(DDCKEY_SRCBLT, &color_key);

   // retunr success
   return(1);
} // end Create_BOB

/////////////////////////////////////////////////////////////////////

int Destroy_BOB(BITMAP_OBJ_PTR bob)
{
   // das BOB zerstören; einfach die Oberfläche freigeben
   if(bob->image)
      (bob->image)->Release();
   else
      return(0);
   // Erflog zurückgeben
   return(1);
} // end Destroy_BOB

//////////////////////////////////////////////////////////////////////

int Draw_BOB(BITMAP_OBJ_PTR bob,        // Bob zeichnen
          LPDIRECTDRAWSURFACE7 dest) // Oberfläche, um den Bob anzuziehen
{
   // Ziehen Sie einen Bob am x, y definiert im BOB auf der in
   // dest definierten Bestimmungsort-Oberfläche an

   RECT dest_rect,  // Das Bestimmungsort-Rechteck
      source_rect; // the source rectangle

   // Füllen Sie den Bestimmungsort rect aus
   dest_rect.left   = bob->x;
   dest_rect.top    = bob->y;
   dest_rect.right  = bob->x+bob->width;
   dest_rect.bottom = bob->y+bob->height;

   // Füllen Sie die Quelle rect aus
   source_rect.left    = 0;
   source_rect.top     = 0;
   source_rect.right   = bob->width;
   source_rect.bottom  = bob->height;

   // Blt zur Bestimmungsort-Oberfläche
   dest->Blt(&dest_rect, bob->image,
            &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
           NULL);

   // return success
   return(1);
} // end Draw_BOB

//////////////////////////////////////////////////////////////////////

int Load_BOB(BITMAP_OBJ_PTR bob,     // Bob, um mit Daten zu laden
          BITMAP_FILE_PTR bitmap, // Bitmap, um Bilddaten davon zu scannen
          int cx, int cy,         // Zelle oder absoluter position um Image davon zu scannen
          int mode)               // Wenn 0 dann cx cy Zellenposition sonst ist
                                  // Cx, Cy ist absoluter coords
{
   // Diese Funktion zieht einen bitmap aus einer bitmap Datei heraus

   UCHAR *source_ptr,  // working pointers
        *dest_ptr;

   DDSURFACEDESC2 ddsd; // Direct Attraktionsoberflächenbeschreibung

   // Prüfen Sie die Weise der Förderung, Zelle beruhend oder absolut
   if (mode==0)
   {
      // re-Compute x,y
      cx = cx*(bob->width+1) +1;
      cy = cy*(bob->height+1) +1;
   } // end if

   // Extrakt bitmap Daten
   source_ptr = bitmap->buffer +
        cy*bitmap->bitmapinfoheader.biWidth+cx;

   // Bekommen Sie den addr zum Bestimmungsort-Oberflächengedächtnis

   // Setz-Größe der Struktur
   ddsd.dwSize = sizeof(ddsd);

   // Schließen Sie die Anzeige-Oberfläche
   (bob->image)->Lock(NULL,
                     &ddsd,
                  DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
                  NULL);

   // Teilen Sie einen Zeigestock der Speicheroberfläche für die Manipulation zu
   dest_ptr = (UCHAR *)ddsd.lpSurface;

   // Wiederholen Sie durch jeden scanline und kopieren Sie bitmap
   for (int index_y=0; index_y<bob->height; index_y++)
   {
      // Kopieren Sie folgende Linie von Daten zum Bestimmungsort
      memcpy(dest_ptr, source_ptr,bob->width);

      // Fortschritt-Zeigestöcke
      dest_ptr   += (ddsd.lPitch);
      source_ptr += bitmap->bitmapinfoheader.biWidth;
   } // end for index_y

   // unlock the surface
   (bob->image)->Unlock(NULL);

   // Setze-Zustand zum laden
   bob->state |= BOB_STATE_LOADED;

   // return success
   return(1);
} // end Load_BOB

///////////////////////////////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd,
                     UINT msg,
                     WPARAM wparam,
                     LPARAM lparam)
{
   // Hauptnachrichtenverarbeitung des System
   PAINTSTRUCT  ps;     // wird in WM_PAINT verwendet
   HDC         hdc;     // Handle für Gerätekontext

   // Was ust un der Nachricht entahlten
   switch(msg)
   {
   case WM_CREATE:
      {
         // do initialization stuff here
         return(0);
      }
      break;
   case WM_PAINT:
      {
         // Fenster einfach anzeigen
         hdc = BeginPaint(hwnd,&ps);

         // End Paint
         EndPaint(hwnd,&ps);
         return(0);
      }
      break;
   case WM_DESTROY:
      {
         // Applikation abbrechen
         PostQuitMessage(0);
         return(0);
      }
      break;
   default:
      break;
   } // end switch

   // nich verarbetete Nachrichten verarbeiten
   return(DefWindowProc(hwnd, msg, wparam, lparam));
} // endWinProc

// WINMAIN //////////////////////////////////////////////////////

int WINAPI WinMain( HINSTANCE hinstance,
                HINSTANCE hprevinstance,
               LPSTR lpcmdline,
               int ncmdshow)

{

   WNDCLASS winclass; // nimmt die von uns erzeugte Klasse auf
   HWND         hwnd; // generischer Fenster-Handle
   MSG           msg; // generische Nachricht
   HDC           hdc; // generische DC
   PAINTSTRUCT    ps; // generische Paintstruct
   memset(&ps, 0, sizeof(PAINTSTRUCT));
   memset(&hdc, 0, sizeof(HDC));

   // Fensterklassenstruktur füllen
   winclass.style              = CS_DBLCLKS | CS_OWNDC |
                                CS_HREDRAW | CS_VREDRAW;
   winclass.lpfnWndProc        = WindowProc;
   winclass.cbClsExtra         = 0;
   winclass.cbWndExtra         = 0;
   winclass.hInstance          = hinstance;
   winclass.hIcon              = LoadIcon(NULL, IDI_APPLICATION);
   winclass.hCursor            = LoadCursor(NULL, IDC_ARROW);
   winclass.hbrBackground      = (HBRUSH)GetStockObject(BLACK_BRUSH);
   winclass.lpszMenuName       = NULL;
   winclass.lpszClassName      = WINDOW_CLASS_NAME;

   // Fensterklasse registrieren
   if (!RegisterClass(&winclass))
      return(0);

   // Fenster erstellen
   if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME,      // Klasse
                            "WinX Game Console",    // Titel
                       WS_POPUP | WS_VISIBLE, 
                       0,0,                    // x,y
                       WINDOW_WIDTH,           // Breite
                       WINDOW_HEIGHT,          // Höhe
                       NULL,                   // Handle f. übergeord. Fenster
                       NULL,                   // Handle für Menü
                       hinstance,              // Instanz
                       NULL)))                 // Parameter für Erstellung

return(0);
// hide The Mouse
ShowCursor(FALSE);
// Fenster-Handle in einer globalen Variablen speichern
main_window_handle = hwnd;
main_instance      = hinstance;

// Alle für doe Spielekonsole spezifischen Initialisierungen vornehmen
Game_Init();
// Eintritt in die Hauptereignisschleife
while(1)
{
   if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
   {
      // Prüfen, ob beendet werden soll
      if (msg.message == WM_QUIT)
         break;

      // Tastenkürzel übersetzen
      TranslateMessage(&msg);
      // Nachricht an die Fensterprozedur senden
      DispatchMessage(&msg);
   } // end if
   // Hier beginnt die Hauptverarbeitung für das Spiel
   Game_Main();
} // end while
// Spiel beenden und Ressurcen freigeben
Game_Shutdown();
// Zurück zu Windows
return(msg.wParam);
} // end WinMain

// WINX GAME PROGRAMMING CONSOLE FUNCTIONS ////////////////

int Game_Init(void *parms)
{
   // In dieser Funktion erfolgt die gesamte Initialisierung
   // für Ihr Spiel
   // Hier steht Ihr Code

   int index; //  looping var

   // Schaffen Sie Gegenstand und Test für den Fehler
   if(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
      return(0);
   // Der "Cooperation level" auf den fenster modus setzen
   if (lpdd->SetCooperativeLevel(main_window_handle,
             DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
            DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

   // Setzte den Display modus
   if (lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)!=DD_OK)
      return(0);

   // Erzeuge die Primare surface
   memset(&ddsd,0,sizeof(ddsd));
   ddsd.dwSize = sizeof(ddsd);
   ddsd.dwFlags = DDSD_CAPS |DDSD_BACKBUFFERCOUNT;

   // Wir müssen dd wissen lassen, dass wir einen Komplex
   // flippable Oberflächenstruktur wollen, Fahnen dafür setzen
   ddsd.ddsCaps.dwCaps =
      DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;

   // Setzen den Backbuffer Counter auf 1
   ddsd.dwBackBufferCount = 1;

   // Schaffen Sie die primäre Oberfläche
   lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL);

   // Frage für den backbuffer d. h. die sekundäre Oberfläche
   ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
   lpddsprimary->GetAttachedSurface(&ddscaps, &lpddsback);

   // Schaffen Sie und fügen Sie Palette bei

   // Schaffen Sie Palette-Daten
   // Beseitigen Sie zuerst alle Einträge, die Verteidigungsprogrammierung
   memset(palette,0,255*sizeof(PALETTEENTRY));

   // Schaffen Sie einen R, G, B, GR Anstieg-Palette
   for (index=0; index<256; index++)
   {
      palette[index].peRed = rand()%256;
      palette[index].peGreen = rand()%256;
      palette[index].peBlue = rand()%256;
      // setzte Flags
      palette[index].peFlags = PC_NOCOLLAPSE;
   } // end for index

   palette[0].peRed = 0;
   palette[0].peGreen = 0;
   palette[0].peBlue = 0;

   // Schaffen Sie jetzt den Palette-Gegenstand

   if (lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_INITIALIZE | DDPCAPS_ALLOW256,
                         palette,&lpddpal,NULL)!=DD_OK)
    return(0);

   // Fügen Sie die Palette der Vorwahl bei
   if (lpddsprimary->SetPalette(lpddpal)!=DD_OK)
      return(0);

   // laden Sie jetzt die 8-Bit-Farbe bitmap
   Load_Bitmap_File(&bitmap8bit, "ROCK8.BMP");

   // Laden Sie jetzt die Palette in den directdraw
   lpddpal->SetEntries(0,0,256,bitmap8bit.palette);

   // create BOBs
   for (index=0; index<NUM_ASTEROIDS; index++)
   {
      // Erstellen sie den BOB
      Create_BOB(&asteroids[index],64,64,0,DDSCAPS_SYSTEMMEMORY);

      // Ziehen Sie ein bitmap Image für den BOB vom großen bitmap heraus
      Load_BOB(&asteroids[index],&bitmap8bit,rand()%4,0,0);

      // Satz zufällige Position und Geschwindigkeit
      asteroids[index].x = rand()%SCREEN_WIDTH;
      asteroids[index].y = rand()%SCREEN_HEIGHT;

      asteroids[index].xv = -8 + rand()%16;
      asteroids[index].yv = -8 + rand()%16;
   } // end for index

   // Klären Sie die primären und sekundären Oberflächen
   memset(&ddbltfx,0,sizeof(ddbltfx));
   ddbltfx.dwSize = sizeof(ddbltfx);
   ddbltfx.dwFillColor = 0;

   lpddsprimary->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&ddbltfx);
   lpddsback->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&ddbltfx);

   // Löschen des Bitmaps
   Unload_Bitmap_File(&bitmap8bit);
   
   // Erfolg zurueckmelden
   return(1);

} // end Game_Init

//////////////////////////////////////////////////////////////////

int Game_Shutdown(void *prams)
{
   // Diese Funktion besteht darin, wo Sie Stilllegung
   // Ihr Spiel und Ausgabe alle Mittel, die Sie zuteilten

   // Löschen des BOBs
   for (int index=0; index<NUM_ASTEROIDS; index++)
      Destroy_BOB(&asteroids[index]);

   // Geben Sie zuerst die Sekundäroberfläche frei
   if  (lpddsback!=NULL)
      lpddsback->Release();

   // Geben Sie jetzt die Primäroberfläche frei
   if  (lpddsprimary!=NULL)
      lpddsprimary->Release();

   // Geben Sie den DirectDraw Gegenstand frei
   if  (lpdd!=NULL)
      lpdd->Release();

   // return success
   return(1);
} // end Game_Shutdown

/////////////////////////////////////////////////////////////////

int Game_Main(void *params)
{
   // dieses ist das workhorse Ihres Spiels,
   // das es ununterbrochen in der Realzeit benannt wird,
   // dieses wie main() in C alle Anrufe für Sie ist,
   // gehen Spiel hier!
   int index; // looping variable

   // check of user is trying to exit
   if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
      PostMessage(main_window_handle, WM_DESTROY,0,0);
   
   // Freier Sekundärbuffer
   memset(&ddbltfx,0,sizeof(ddbltfx));
   ddbltfx.dwSize = sizeof(ddbltfx);
   ddbltfx.dwFillColor = 0;
   lpddsback->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&ddbltfx);

   // Move asteroids
   for (index=0; index<NUM_ASTEROIDS; index++)
   {
      asteroids[index].x+=asteroids[index].xv;
      asteroids[index].y+=asteroids[index].yv;
   } // end for index

   // Überprüfen Sie, ob der Asteroids Von der Bildbegrenzung verschwindet
   for (index=0; index<NUM_ASTEROIDS; index++)
   {
      // x bounds
      if (asteroids[index].x > SCREEN_WIDTH)
         asteroids[index].x = -asteroids[index].width;
      else
         if (asteroids[index].x < -asteroids[index].width)
            asteroids[index].x = SCREEN_WIDTH;
      
      // y bounds
      if (asteroids[index].y > SCREEN_HEIGHT)
         asteroids[index].y = -asteroids[index].height;
      else
         if (asteroids[index].y < -asteroids[index].height)
            asteroids[index].y = SCREEN_HEIGHT;
   } // end for index

// Draw all asteroids
   for (index=0; index<NUM_ASTEROIDS; index++)
      Draw_BOB(&asteroids[index], lpddsback);

   // flip pages
   while(lpddsprimary->Flip(NULL, DDFLIP_WAIT)!=DD_OK);

   // slow things down
   Sleep(30);

   // return success
   return(1);
} // end Game_Main
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 16:44    Titel: Antworten mit Zitat

ALso den letzte fehler habe ich gefunden und säubern können, aber das prgrammt stürtzab es kommt ein schwarzes bild aber vor her sagt er noch Datenverluste an nemlich bei
CPP:
 return(msg.wParam);
kann mir da jemand helfen?
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
Patrick
Dark JLI Master



Anmeldedatum: 25.10.2004
Beiträge: 1895
Wohnort: Düren
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 17:01    Titel: Antworten mit Zitat

CPP:
return (static_cast<int>(msg.wParam));


Die Arme Datenbank Sad Soviel überflüssiger Code
_________________
'Wer der Beste sein will muss nach Perfektion streben und jede Gelegenheit nutzen sich zu verbessern.' - KIA
[ German Game Dev | Boardsuche hilft sehr oft | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 39
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 17:16    Titel: Antworten mit Zitat

Patrick hat Folgendes geschrieben:
CPP:
return (static_cast<int>(msg.wParam));


Die Arme Datenbank Sad Soviel überflüssiger Code


Det kommt da rein?
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
GreveN
JLI Master


Alter: 38
Anmeldedatum: 08.01.2004
Beiträge: 901
Wohnort: Sachsen - Dresden
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 17:18    Titel: Antworten mit Zitat

Na was sonst?

Wobei mir gerade der Sinn etwas vorborgen bleibt, da WPARAM afaik (!!) sowieso nur ein typedef für int ist.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Yahoo Messenger MSN Messenger
Patrick
Dark JLI Master



Anmeldedatum: 25.10.2004
Beiträge: 1895
Wohnort: Düren
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 17:29    Titel: Antworten mit Zitat

GreveN
FALSCH!

CPP:
typedef unsigned int WPARAM;

// bzw.

typedef _w64 unsigned int WPARAM;

und einen unsigned int kann man nicht an Windows zurückgeben! Der erwartet explizit (signed) int Wink
_________________
'Wer der Beste sein will muss nach Perfektion streben und jede Gelegenheit nutzen sich zu verbessern.' - KIA
[ German Game Dev | Boardsuche hilft sehr oft | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
GreveN
JLI Master


Alter: 38
Anmeldedatum: 08.01.2004
Beiträge: 901
Wohnort: Sachsen - Dresden
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 17:56    Titel: Antworten mit Zitat

Oha, das klingt einleuchtend...
Aaaaaaber, mein Codeblocks liefert ein Template für Win32-Anwendungen mit und da wird das auch einfach so gehandled.
Gab eigentlich auch nie Probleme. *kratz*
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Yahoo Messenger MSN Messenger
Patrick
Dark JLI Master



Anmeldedatum: 25.10.2004
Beiträge: 1895
Wohnort: Düren
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 19:24    Titel: Antworten mit Zitat

GreveN
Liegt daran das der GCC nicht so pingelig ist wie gute Compiler.
_________________
'Wer der Beste sein will muss nach Perfektion streben und jede Gelegenheit nutzen sich zu verbessern.' - KIA
[ German Game Dev | Boardsuche hilft sehr oft | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Jones
Senior JLI'ler


Alter: 33
Anmeldedatum: 03.03.2005
Beiträge: 208
Wohnort: Köln
Medaillen: Keine

BeitragVerfasst am: 06.12.2005, 19:25    Titel: Antworten mit Zitat

So, fangt bitte erst gar nicht an über Compiler zu streiten Wink
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik Alle Zeiten sind GMT
Gehe zu Seite 1, 2  Weiter
Seite 1 von 2

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum