Autor Beitrag
De-Roma
Hält's aus hier
Beiträge: 8

WinXP - HOME
d7
BeitragVerfasst: Fr 16.07.04 10:14 
Ich würde gerne probehalber ein spiel schreiben bei dem erfasst werden soll ob ein immage (auto) von einem bestimmten weg abkommt und ob es in einen bestimmten Bereich des spielfeldes eingedrungen ist (zum beispiel ein see) ==> Kollisionsabfrage ???

ich verwende dazu eigentlich nur das standart formular auf welchem ich ein immage als spielfeld ablege

darüber kommt ein weiteres immage welches durch tastensteuerung bewegt werden kann

wenn das immage von der straße abkommt soll die bewegung verlangsamt werden
wenn es in einen fluß oder see gerät soll es stehen bleiben...


das bewegen ist das einzigste was funktioniert
maxk
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 1696
Erhaltene Danke: 1

Win XP, Debian Lenny
Delphi 6 Personal
BeitragVerfasst: Fr 16.07.04 10:16 

_________________
Ein Computer wird das tun, was Du programmierst - nicht das, was Du willst.
De-Roma Threadstarter
Hält's aus hier
Beiträge: 8

WinXP - HOME
d7
BeitragVerfasst: Fr 16.07.04 10:36 
??? das hilft mir irgendwie nicht so recht weiter die topics habe ich schon gelesen
Gandalfus
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 129



BeitragVerfasst: Fr 16.07.04 16:47 
Benutze eine BB(Bounding Box) also ein Rechtecke um das Fahrzeug. Rechtecke kann man ziemlich leicht auf kollision testen.

z.B.:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
function RectinRect(rect1,rect2: Trect): boolean;
begin
  result := true;
  if (rect1.Left > rect2.BottomRight.x) then result:=false;
  if (rect1.top > rect2.BottomRight.y) then result:=false;
  if (rect2.Left > rect1.BottomRight.x) then result:=false;
  if (rect2.top > rect1.BottomRight.y) then result:=false;
end;


oder IntersectRect (oder so ähnlich).

Eine Pixelgenaue Kollision ist ein ziemlicher Brocken. Relativ leicht ginge das noch mit Regions allerdings bekommt man da auch schnell Geschwindiglkeits Probleme.


Moderiert von user profile iconPeter Lustig: Code- durch Delphi-Tags ersetzt.

_________________
Wennn man feststellt, dass es drei Moeglichkeiten gibt, die einen Vorgang schiefgehen lassen koennen und man diese ausschaltet, entstehen automatisch drei neue Moeglichkeiten.
Raphael O.
ontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic starofftopic star
Beiträge: 1596


VS 2013
BeitragVerfasst: Fr 16.07.04 16:54 
habe vor urzeiten mal sowas gemacht, was ich heute als verbrechen bezeichnen würde, aber was damals ganz gut getaugt hat, auch wenn es unendlich langsam ist, gegenüber anderen methoden:
ich habe ein zweites (hintergrund)image genommen, das in den Farben gelb weiß und pink (fuchsia) eingefärbt war...
gelb hieß sand -> langsam fahren
weiß -> normal
pink -> nicht befahrbar

und dann habe ich die Farbe an der Position des Autos auf diesem Image nachgeschaut und dann entsprechend reagiert...
war echt spaßig das gegen meinen Bruder an einem PC zu spielen und das das verloren gegangen ist (Format C: ) ärgert mich heute noch *grml*

ist im Prinzip recht einfach umzusetzen und sollte es für deine ZWecke reichen hilft es ja vielleciht ;-)
Gandalfus
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 129



BeitragVerfasst: Fr 16.07.04 17:10 
Hmm ich sollte die frage lesen.

Du nimmst eine Karte die aus vielen Kästchen besteht und Speicherst für jedes Kästchen wie schnell man darauf fahren kann.
Achja zeichnen mit TCanvas (TBitmap, canvas.draw, usw.) und KEIN TImage benutzen.

Fiji-Fighter Methode ist nicht so der Hit es sollte aber auch gehen.

_________________
Wennn man feststellt, dass es drei Moeglichkeiten gibt, die einen Vorgang schiefgehen lassen koennen und man diese ausschaltet, entstehen automatisch drei neue Moeglichkeiten.
Raphael O.
ontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic starofftopic star
Beiträge: 1596


VS 2013
BeitragVerfasst: Fr 16.07.04 17:53 
Gandalfus hat folgendes geschrieben:
Fiji-Fighter Methode ist nicht so der Hit es sollte aber auch gehen.

habe ich ja auch geschrieben...
hier mal eine Auflistung der Vor- und NAchteile:
ausblenden Vorteile
1:
2:
schnell erstellte "Kollisionsmaps" (sofern man als "Map" auch nur ein Image hat...)
leichte und schnelle Implementation

ausblenden Nachteile
1:
2:
3:
sehr langsam
hoher speicherverbrauch
-> nur für kleine und einfache MAps zu gebrauchen


dann muss man selber sehen, ob man es trotzdem gebrauchen will und kann...

für mein Mini-Autorennen damals war es allerdings ideal, da ich so schnell neue Maps ohne Aufwand herstellen konnte...

achja... die ziellinie war schwarz und die "boxenlinien" waren grün...
(man durfte nicht zu schnell durch die Box durchfahren und musste auftanken alle paar runden...
(davon muss ich unbedingt ein Remake machen *lol*)
Blitz.XP
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 26



BeitragVerfasst: Sa 17.07.04 09:32 
wenn man delphiX nimmt dann hat man schon eine komplette Pixelgenau Kollisionabfrage dabei!
Mechanic
Hält's aus hier
Beiträge: 2



BeitragVerfasst: Sa 17.07.04 10:08 
Hallo,

na - wie wärs mit der Variante :


(***********************************************************;
; comptblt_: Vergleicht die Pixel eines DIB's mit den ;
; Pixeln eines anderen DIB's in dem übergebenen;
; Rechteck unter Berücksichtigung einer ;
; transparenten Farbe; kann zur Pixelgenauen ;
; Kollisonsabfrage benutzt werden ;
;-----------------------------------------------------------;
; Parameter: ;
; _SourceOffset: Quelladresse ;
; _DestOffset: Zieladresse ;
; _dwWidth: Breite in Pixeln ;
; _dwHeight: Höhe in Pixeln ;
; _dwScanS: Bytes in einer Zeile des Quelldibs ;
; _dwScanD: Bytes in einer Zeile des Zieldibs ;
; _bTranClr: Transparente Farbe ;
; _equal: enthält nach Beendigung der Funktion ;
; bei Gleichheit 1 ;
; ;
;***********************************************************)

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
procedure comptblt_;assembler;
asm
        mov ecx, dwWidth       //Breite
        or ecx,ecx             //=0?
        jz @ctcdb_nomore       // Test ob überhaupt nötig

        mov edx, dwHeight      // EDX zählt Zeilen
        mov ah, bTranClr     // AL enthält transparente Farbe

        mov esi,SourceOffset   // Quelladresse
        mov edi, DestOffset    // Zieladresse

        sub dwScanD,ecx        // überstehende Ziel-Pixel
        sub dwScanS,ecx        // überstehende Quell-Pixel

        mov ebx,ecx            // Für später sichern

    @ctcdb_morelines:
        mov ecx, ebx           // ECX zählt die Pixel
        shr ecx,2              // durch 4 teilen,
                               // da immer 4 Pixel zusammen

        jz @ctcdb_nextscan     // Zeile beginnen

// Um die ständigen Sprungbefehle am Ende der nun nötigen
// Schleife zu umgehen, wird der Code zum Kopieren von Pixeln
// 4 Mal hintereinander geschrieben, so werden alle vier
// Pixel drei Sprungbefehle gespart.
// Es existieren aber zwei dieser Schleifen, eine für
// transparente Pixel und eine für nicht transparente Pixel.
// Es wird also in beiden Schleifen ein Pixel gelesen und mit
// der transparenten Farbe verglichen, befindet sich das
// Programm in der falschen Schleife, so wird einfach in die
// andere Schleife, an dieselbe Position,  wie in der
// aktuellen Schleife gesprungen.

  // Schleife für transparente Pixel

    @ctcdb_same:
        mov al, [esi]          //Pixel lesen
        cmp al, ah             //noch transparent?
        jne @ctcdb_diff0       //->nein, springen

    @ctcdb_same0:
        mov al, [esi+1]        //Pixel lesen
        cmp al, ah             //noch transparent?
        jne @ctcdb_diff1       //->nein, springen

    @ctcdb_same1:
        mov al, [esi+2]        //Pixel lesen
        cmp al, ah             //noch transparent?
        jne @ctcdb_diff2       //->nein, springen

    @ctcdb_same2:
        mov al, [esi+3]        //Pixel lesen
        cmp al, ah             //noch transparent?
        jne @ctcdb_diff3       //->nein, springen

    @ctcdb_same3:
        add edi,4              //Ziel-Pixel erhöhen
        add esi,4              //Quell-Pixel erhöhen
        dec ecx               //verbleibende Pixel verringern
        jnz @ctcdb_same        //Noch Pixel übrig
        jz  @ctcdb_nextscan    //Zeile zuende

  // Schleife für nicht transparente Pixel


    @ctcdb_diff:
        mov al, [esi]          //Pixel lesen
        cmp al, ah             //doch transparent?
        je @ctcdb_same0        //->ja, springen

    @ctcdb_diff0:
        cmp [edi],al           //Pixel vergleichen
        jne @ctcdb_notequal    //->nicht gleich, Abbruch
        mov al, [esi+1]        //Pixel lesen
        cmp al, ah             //doch transparent?
        je @ctcdb_same1        //->ja, springen

    @ctcdb_diff1:
        cmp [edi+1],al         //Pixel vergleichen
        jne @ctcdb_notequal    //->nicht gleich, Abbruch
        mov al, [esi+2]        //Pixel lesen
        cmp al, ah             //doch transparent?
        je @ctcdb_same2        //->ja, springen

    @ctcdb_diff2:
        cmp [edi+2],al         //Pixel vergleichen
        jne @ctcdb_notequal    //->nicht gleich, Abbruch
        mov al, [esi+3]        //Pixel lesen
        cmp al, ah             //doch transparent?
        je @ctcdb_same3        //->ja, springen

    @ctcdb_diff3:
        cmp [edi+3],al         //Pixel vergleichen
        jne @ctcdb_notequal    //->nicht gleich, Abbruch

        add edi,4              //Ziel-Pixel erhöhen
        add esi,4              //Quell-Pixel erhöhen
        dec ecx               //verbleibende Pixel verringern
        jnz @ctcdb_diff        //noch Pixel übrig
        jz @ctcdb_nextscan     //Zeile zuende

  // Neue Zeile beginnen, aber erst noch
  // auf überstehende Pixel prüfen

    @ctcdb_nextscan:
        mov ecx,ebx            //Breite holen
        and ecx,11b           //untere 2 Bits=restliche Pixel
        jnz @ctcdb_oddstuff    //es sind noch Pixel übrig

    @ctcdb_nextscan1:
        add esi, dwScanS       //Zur nächsten Quell-Zeile
        add edi, dwScanD       //Zur nächsten Ziel-Zeile

        dec edx              //verbleibende Zeilen verringern
        jnz @ctcdb_morelines   // es sind noch Zeilen übrig
        jz @ctcdb_nomore       // keine Zeilen mehr, Abbruch

// Wenn die Breite kein Vielfaches von 4 ist, müssen wir hier
// noch die überstehenden Pixel kopieren

    @ctcdb_oddstuff:
        inc ecx                //um eins erhöhen
    @ctcdb_oddloop:
        dec ecx               //verbleindene Pixel verringern
        jz  @ctcdb_nextscan1   //keine Pixel?->nächte Zeile
        mov al, [esi]          //Pixel lesen
        inc esi                //nächster Quell-Pixel
        inc edi                //nächster Ziel-Pixel
        cmp al, ah             //Pixel transparent?
        je  @ctcdb_oddloop     //->ja, dann nicht schreiben
        cmp [edi-1],al         //Pixel vergleichen
        jne @ctcdb_notequal    //->nicht gleich, Abbruch
        jmp @ctcdb_oddloop     //zum Schleichenanfang

    @ctcdb_nomore:
        mov equal,1            //DIB's vollkommen gleich
    @ctcdb_notequal:
end;


Stammt aus dem Buch:
Spiele programmieren mit Delphi von
Andreas F.Golla und C.A.D. Kassler
aus dem Jahre 2000

:)

Für 2D Games immer noch sehr brauchbar.

Grüße
Markus
Gandalfus
ontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic starofftopic star
Beiträge: 129



BeitragVerfasst: Sa 17.07.04 12:22 
www.codeworx.org/gam..._kollision_pixel.php

ist da ziemlich gut erklärt.

_________________
Wennn man feststellt, dass es drei Moeglichkeiten gibt, die einen Vorgang schiefgehen lassen koennen und man diese ausschaltet, entstehen automatisch drei neue Moeglichkeiten.