Kollisionsabfrage für Gegner

[jojo1541]

Hallo, ich bins mal wieder, und nein, diesmal ist es kein saudummer Fehler von mir und ich versuch, so ziemlich alles, was man über den Code wissen muss, zu posten.

Also, hier die Frage, ich zeichne ein Jump'n'run-Level via

Code: Alles auswählen

 
DataSection
leveldaten:
data.l 1,1,1,1,1,1
data.l 1,0,0,0,0,1
data.l 1,1,1,1,1,1
;ist natürlich nicht das ganze Level


Procedure LevelEinlesen()
  Restore leveldata
  For Y = 0 To 30
    For X = 0 To 24
      Read LevelDaten(Y,X)
    Next
  Next
EndProcedure

Procedure LevelAusgeben()
  For Y = 0 To 30
    For X = 0 To 24
      For i = 1 To 40
      If LevelDaten(Y,X) = i
        DisplayTransparentSprite(i,X * 32, Y * 32 - scroll_y)
      EndIf
      Next
    Next
  Next
EndProcedure

und frage mit diesem Code

Code: Alles auswählen

If KeyboardPushed(#PB_Key_Left)
    If LevelDaten(((player_y +16)+ scroll_y) /32,(player_x-4) /32)=0 And LevelDaten(((player_y +48)+ scroll_y) /32,(player_x-4)/32)=0
      player_x-4
    endif

ElseIf KeyboardPushed(#PB_Key_Right)
    
     If LevelDaten(((player_y +16)+ scroll_y) /32,(player_x +32) /32)=0 And LevelDaten(((player_y +48)+ scroll_y) /32,(player_x +32)/32)=0
    player_x+4
    
    EndIf
EndIf
   

    

für jedes Tile ab, (durch die man laufen können soll) ob man durch das nächste tile noch laufen kann. das wären die Tiles 0, 13,14,15,16,17

Muss ich jetzt auch für jeden Gegner die Kollision so berechnen, oder gibt es da einen einfacheren und vor allem schnelleren Weg?

[Kaeru Gaman]

ein paar beispielcodes für koordinatenchecks:
http://www.purebasic.fr/german/viewtopic.php?t=9093

[jojo1541]

Danke.
Vor allem mit

Code: Alles auswählen

SectorCollision()

kann ich was anfangen.

Edit: aber eine Frage noch: Sectorcollision bezieht sich ja auch auf zwei sprites. So müsste ich ja für jedes Tile in meiner map diesen Befehl eingeben, oder?

[Kaeru Gaman]

deine tile-abfrage sieht gut aus, allerdings ist mir nicht ganz klar, warum du zwei tiles abfragst...
oder sollen das die beiden eckpunkte sein?
ist halt komisch, dass du y+16 und y+48 nimmst, nicht y und y+32...
aber wirst dir schon was bei gedacht haben.

für gegner-map-checks musst du's genauso machen, das ist schon der schnellste weg.
immer checken, ob die eckpunkte des betroffenen sprites kurz vor freien tiles stehen.

vereinfachen kannst du das nur, wenn du die bewegung jedes objekts auf ganze tiles beschränkst,
also immer 32pix in eine richtung gehst, bevor du das nächste tile checkst und die richtung änderst.
sozusagen pacman-prinzip.


SectorCollision ist eher für player-gegner-checks geeignet, nicht für die map.

[jojo1541]

Ok danke, das mit Sectorcollision() is mir kurz darauf klargeworden, ich hatte es nur am Anfang direkt auf meine Frage mit der Kollisionsabfrage mit der Map bezogen.^^

[Kaeru Gaman]

hatte deine frage "für jeden gegner" zuerst nicht genau genug interpretiert und auf player-gegner-check bezogen,
deswegen hatte ich auf den thread hingewiesen.

[jojo1541]

War ja auch sehr nützlich für mich.^^

Aber noch eine Frage: ich frage ja die Y-player Coordinate ,mit der Variable scroll_Y so ab, dass der Spieler immer in der Mitte des Screens bleibt. also:

Code: Alles auswählen

If LevelDaten(((player_y +64)+ scroll_y) /32,((player_x +16) /32)= 1 
            jump = 0
            ;genaue position setzen, falls die figur im tile steht
            temp = (player_y + scroll_y) /32
            scroll_y = (temp*32)-player_y
         EndIf

Was müsste ich mit dem Gegnerischen Sprite machen, damit er immer an der selben Y-Stelle in der Map bleibt?

[Kaeru Gaman]

bei dem Gegner solltest du dann mit absoluten Koordinaten arbeiten,
also in der Gegner-Struct selber die Koordinaten des Gegners relativ zum Kartenursprung speichern,
also zu der linken oberen Ecke des linkesten obersten Tile der Map.

zu relativ-koordinaten kannst du dir auch mal ein Beipiel zu Maus-over-Tilemap ansehen:
http://www.purebasic.fr/german/viewtopi ... 689#116689
die grafik mit den tiles ist ein posting weiter oben...

im Übrigen ist es u.U. auch praktisch, beim Player mit Absolutkoordinaten zu arbeiten...

für die Gegner-Player-Kollision ist es in jedem Fall wichtig, die selbe Koordinatenrelation zu benutzen.
also, wenn der Player relativ zum Screen positioniert wird, der Gegner aber relativ zur Map,
musst du noch die Map-Screen-Relation mit einberechnen,
bevor du Playerkoordinaten mit Gegnerkoordinaten vergleichst.
(hoffe, das war nicht zu kompliziert ausgedrückt... )


PS:
also, am besten wäre es wirklich, mit Relativkoordinaten zum Kartenursprung zu arbeiten.
für den Screen, für den Player und für die Gegner.

wenn der Player auf dem Screen stillstehen soll, ist das sogar noch einfacher,
dann brauchst du nur die Screenkoordinaten oder die Playerkoordinaten,
und das jew. andere Koordinatenpaar hat dazu eine feste Differenz.

[jojo1541]

Naja, der Player kann nach links und rechts laufen, nur nach oben wird gescrollt...
warte mal, stell nen beschrifteten Screenshot rein...

http://img27.imageshack.us/img27/606/screenshotv.bmp

[Kaeru Gaman]

ja das muss wohl irgendwie untergegangen sein....

wie du das mit dem screenshot geschafft hast, dass du ein png mit falscher bmp-endung auf imageshack hast, ist verwunderlich....

dein scroll_y.... das ist wohl die feinscroll-koordinate deiner ganzen map?

also, du berechnest deine Player-Map interaktion über
scroll_y + player_y + 64
das ist die absolute y-Koordinate der Unterkante deines Playersprites auf der Map.

für deine Gegnersprites musst du jetzt mit absoluten Koordinaten arbeiten,
d.h. dein Gegner selber befindet sich auf einer Koordinate auf der Map.
du berechnest direkt mit
gegner_y + 64
die unterkante deines Gegners,
aber für die Darstellung auf dem Bildschirm berechnest du
gegner_y - scroll_y

nochmal zusammenfassend:
Player:
Map-Interaktion: LevelDaten( player_x, scroll_y + player_y + player_hoehe )
Darstellung: DisplaySprite( player_x, player_y )

Gegner:
Map-Interaktion: LevelDaten( gegner_x, gegner_y + gegner_hoehe )
Darstellung: DisplaySprite( gegner_x, gegner_y - scroll_y )

hab die /32 mal weggelassen, damit man das wesentliche sieht:
dein player_y ist eine Bildschirmkoordinate also immer relativ zur Oberkante des Screens.
dein gegner_y ist eine absolute Koordinate, also immer relativ zur Oberkante der Map.