 |
JLI Spieleprogrammierung
|
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
|
Verfasst am: 06.12.2005, 00:56 Titel: flags Probleme |
|
|
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 |
|
 |
Christian Rousselle Site Admin

Alter: 48 Anmeldedatum: 19.07.2002 Beiträge: 1630
Medaillen: Keine
|
Verfasst am: 06.12.2005, 08:56 Titel: |
|
|
Tippfehler: falgs (direkt im Funktionskopf) |
|
Nach oben |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 11:04 Titel: |
|
|
Christian Rousselle hat Folgendes geschrieben: | Tippfehler: falgs (direkt im Funktionskopf) |
Ich danke dir Christian. ist ma ja peinlich das ich es nicht selber finde den fehler |
|
Nach oben |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 11:16 Titel: |
|
|
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 |
|
 |
Kampfhund Super JLI'ler
Alter: 42 Anmeldedatum: 20.07.2002 Beiträge: 408
Medaillen: Keine
|
Verfasst am: 06.12.2005, 13:10 Titel: |
|
|
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 |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 13:17 Titel: |
|
|
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 |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 13:19 Titel: |
|
|
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 |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 16:44 Titel: |
|
|
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 kann mir da jemand helfen? |
|
Nach oben |
|
 |
Patrick Dark JLI Master

Anmeldedatum: 25.10.2004 Beiträge: 1895 Wohnort: Düren Medaillen: Keine
|
|
Nach oben |
|
 |
City Hunter Super JLI'ler
Alter: 39 Anmeldedatum: 18.04.2004 Beiträge: 330 Wohnort: Berlin Medaillen: Keine
|
Verfasst am: 06.12.2005, 17:16 Titel: |
|
|
Patrick hat Folgendes geschrieben: | CPP: | return (static_cast<int>(msg.wParam)); |
Die Arme Datenbank Soviel überflüssiger Code |
Det kommt da rein? |
|
Nach oben |
|
 |
GreveN JLI Master

Alter: 38 Anmeldedatum: 08.01.2004 Beiträge: 901 Wohnort: Sachsen - Dresden Medaillen: Keine
|
Verfasst am: 06.12.2005, 17:18 Titel: |
|
|
Na was sonst?
Wobei mir gerade der Sinn etwas vorborgen bleibt, da WPARAM afaik (!!) sowieso nur ein typedef für int ist. |
|
Nach oben |
|
 |
Patrick Dark JLI Master

Anmeldedatum: 25.10.2004 Beiträge: 1895 Wohnort: Düren Medaillen: Keine
|
Verfasst am: 06.12.2005, 17:29 Titel: |
|
|
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  _________________ '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 |
|
 |
GreveN JLI Master

Alter: 38 Anmeldedatum: 08.01.2004 Beiträge: 901 Wohnort: Sachsen - Dresden Medaillen: Keine
|
Verfasst am: 06.12.2005, 17:56 Titel: |
|
|
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 |
|
 |
Patrick Dark JLI Master

Anmeldedatum: 25.10.2004 Beiträge: 1895 Wohnort: Düren Medaillen: Keine
|
|
Nach oben |
|
 |
Jones Senior JLI'ler

Alter: 33 Anmeldedatum: 03.03.2005 Beiträge: 208 Wohnort: Köln Medaillen: Keine
|
Verfasst am: 06.12.2005, 19:25 Titel: |
|
|
So, fangt bitte erst gar nicht an über Compiler zu streiten  |
|
Nach oben |
|
 |
|
|
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
|