PureBoard

Verfasst: **09.01.2013 23:28**

So, hab den Code nochmal überflogen (und selbst in meinem Beispielcode Fehler gefunden

)

statt so:

;für links:
if px=>20   ;ganz wichtig, da du sonst das Array überfordern könntest ;)
  spieler_raster_x = Round(px/20,1)-1        ;geht auch, wenn du das Round weg lässt. Wollte es nur sauber schreiben.
  spieler_raster_y = (py)/20
  If Block(spieler_raster_x, spieler_raster_y)\id  = 0
...

;für rechts:
if px< "___Anzahl_Boxen____"-20
  spieler_raster_x = Round(px/20,1)+1
  spieler_raster_y = (py)/20
  If Block(spieler_raster_x, spieler_raster_y)\id  = 0

muss es so aussehen:

Code: Alles auswählen

;für links:
if px=>20   ;ganz wichtig, da du sonst das Array überfordern könntest ;)
  spieler_raster_x = Round((px-Schrittweite)/20,1)                                                  <<--
  spieler_raster_y = (py)/20
  If Block(spieler_raster_x, spieler_raster_y)\id  = 0
...

;für rechts:
if px< "___Anzahl_Boxen____"-20
  spieler_raster_x = Round((px+Schrittweite)/20,1)                                                  <<--
  spieler_raster_y = (py)/20
  If Block(spieler_raster_x, spieler_raster_y)\id  = 0

Nun zu deinem Code. Du willst zwar einen 2D-Körper im Level umherscheuchen, aber berechnest alles nur mit einem Punkt (px,py).
Du hast in keinster Weise die Ausdehnungen berücksichtigt. Zusätzlich pinnst du das Sprite(0) direkt an (px,py). D.h. das Bild wird so dargestellt, dass die linke obere Ecke auf (px,py) liegt. Aus diesem Grund kommt es dir auch so vor, als würdest du beim nach links Bewegen alle Kollisionen richtig sehen und beim nach rechts Laufen in der Wand verschwinden. (Vllt war dir das aber schon bewusst)
Und nun zum Fallen: Du erhöhst beim Fallen ohne Kollision dein fg immer um 1. Besonders große Höhen würden also fg`s erzeugen, die deutlich über einer Blockhöhe liegen. Beim Überprüfen gehst du aber immer nur vom ganzen "Schritt" aus und lässt dabei unter Umständen Blöcke unbeachtet, die zwischen dir und dem Ziel liegen. (Schleife von py -> py+fg ; Schritt=Blockhöhe)

Als Tipp: Lass die Ausdehnung deiner Figur erstmal weg, da gibt es noch ein paar schöne Fallen. Schieb dein Sprite mal nach px-10|py-10 und guck nur, ob der Mittelpunkt deines Kreises richtig kollidiert.

Verfasst: **11.01.2013 16:55**

man-in-black hat geschrieben: Nun zu deinem Code. Du willst zwar einen 2D-Körper im Level umherscheuchen, aber berechnest alles nur mit einem Punkt (px,py).
Du hast in keinster Weise die Ausdehnungen berücksichtigt. Zusätzlich pinnst du das Sprite(0) direkt an (px,py). D.h. das Bild wird so dargestellt, dass die linke obere Ecke auf (px,py) liegt.

Ich habe px, py mal um 10 verschoben, wie du es vorgeschlagen hast, damit ist es ein wenig einfacher für die Kollision links und rechts.

man-in-black hat geschrieben: Und nun zum Fallen: Du erhöhst beim Fallen ohne Kollision dein fg immer um 1. Besonders große Höhen würden also fg`s erzeugen, die deutlich über einer Blockhöhe liegen. Beim Überprüfen gehst du aber immer nur vom ganzen "Schritt" aus und lässt dabei unter Umständen Blöcke unbeachtet, die zwischen dir und dem Ziel liegen. (Schleife von py -> py+fg ; Schritt=Blockhöhe)

Hier komme ich einfach auf keinen grünen Zweig

. Die einzige Möglichkeit die mir noch einfällt, wäre SpritePixelCollision zu nutzen, dann wäre ich aber wieder bei meinen anfangsproblemen.

Und nach einem Beispiel habe ich auchschon gesucht, aber bis jetzt keines gefunden in dem die Schwerkraft realisiert wurde so dass ich es verstehe.

Verfasst: **11.01.2013 19:50**

Was willst du schonwieder mit SpritePixelCollision()?

Überleg doch mal, was der Befehl macht! Damit vergleichst du, ob 2 Sprites sich überlappen.
Du musst also schon wissen, welche 2 Sprites du vergleichen willst und genau da liegt doch der Hund begraben!

Hab das ganze mal illustriert:

Bild

links:
rot = fg
gelb=Spieler
grün=(px,py)
braun=(px,py+fg)
grau=NICHT BEACHTETE FELDER

rechts: (dein Levelaufbau)
hell= "\id > 0"
dunkel= "\maxHoehe <> 0"

Nachdem du dich da mal ein bisschen reinversetzt hast, überleg, was passiert, wenn eines der NICHT BEACHTETEN FELDER (grau)
der obereste Block in der aktuellen Spalte ist (dunkelgrün). Richtig! Der Spieler wird dann IMMER "\maxHoehe = 0" auf die Frage, ob der überprüfte Block der oberste ist, erhalten. Du könntest zwar rumpfuschen und "\maxHoehe = 0" zu "\id = 0" ändern, schiebst das Problem aber auf einen späteren Zeitpunkt (z.B. wenn du Höhlen einbauen willst,...)

Um die grauen Felder zu berücksichtigen, musst du Schrittweise (Blockhöhe) die Blöcke runterklettern, bis zu BlockNr=round(fg/20,0)
Wenn beim aktuellen Schritt nur "Luft" (\id=0) ist, wird py um die Blockhöhe verschoben. Tritt eine Kollision auf, so wird die Schleife abgebrochen und fg fällt auf 0 zurück. Beim letzten Schritt musst du aber darauf achten, dass "fg-BlockNr*20=?" (fg%20) einen Rest
ausspuckt. Also py keine ganze Blockhöhe, sondern nur fg%20 zu verschieben ist!

mit Absicht kein c&p code :P

Hoffe, das war jetzt anschaulich

MIB

Verfasst: **12.01.2013 14:54**

Danke dass du dir die Mühe gemacht hast das extra für mich zu illustrieren

. Ich glaub zum größten Teil hab ich es jetzt begriffen.
Ich habe jetzt eine Variable eingebaut, die die Höhe über dem Boden prüft, und lasse sobald fg die Höhe überschreiten den Rest zu pY hinzuzählen.
Jetzt ist aber der Fall sehr abgehackt und zackelig geworden.

Code: Alles auswählen

ExamineKeyboard()
   
  pY + fg                                ; Schwerkraft
  pHoehe - Round(fg/20,1)
  
  If Block(px/20, (py/20)+m)\maxHoehe = 0
    m + 1
    If ((py)/20)+m => 45
      m = 0
    EndIf
  Else
    pHoehe = m                           ; Höhe über der Erde
    m = 0
  EndIf
  
  If pHoehe - Round(fg/20,1) > 0         ; Check der übersprungenen Blöcke
    fg + 1
  Else
    py + pHoehe                          ; Das letzte Stück zum Boden (funktioniert nicht)
    fg = 0
  EndIf

Verfasst: **12.01.2013 15:57**

Ich habe deine Änderungen jetzt nur mal überflogen, aber
bereits den Eindruck, dass es viel zu kompliziert oder falsch
umgesetzt ist. (Ich hab dir doch fasst Schritt für Schritt gesagt, was zu tun ist. Einfach nur in Code umschreiben :P )

Dann mal anders. Wir denken uns jetzt mal, dass jeder Frame eine Momentaufnahme ist (ist es eigt auch^^).
IN diesem zugefrorenen Zustand willst du jetzt in eine (später alle) Himmelsrichtungen testen, wie dicht die nächsten Blockaden sind.
Du hast also einen raumfesten Spieler, der knapp über dem Boden schwebt.
Warum dann nicht einen kleinen Punkt senkrecht nach unten WANDERN lassen? Das Problem ist nun, dass du dich von der
Momentaufnahme entkoppeln musst, da sonst nur ein Schritt deines kleinen Punktes pro Frame erfolgen würde. Doch mit jedem
Frame ändert sich die Welt um den Spieler wieder. Lösung: Wir bauen eine Unterschleife ein, die den kleinen Punkt pro Frame einmal vom Spieler bis zum Boden laufen lässt. (Bloß die seh ich bei dir nicht)
In deinem Beispiel reicht es, wenn die Schleife den Punkt immer um <Blockhöhe> nach unten verschiebt (px,py+n*20), n-Schritt.
Und wenn sie von py->py+fg läuft. Natürlich kannst du auch wirklich ALLE Pixel unter dem Spieler testen, hast dann aber im Endeffekt
20x den gleichen Block getestet...

(wenn das hier so weiter geht, werd ich alle meine Posts als Roman verkaufen xD )

Code: Alles auswählen

repeat                                     ;deine Hauptschleife! 1 Durchlauf = 1 Frame
tu_dies()
...
tu_das()


;teste Schwerkraft
if block(px/20,(py+1)/20) = luft               ;erstmal feststellen, ob wir überhaupt fallen. wenn nicht, können wir auch nicht schneller werden
  fg+1
endif

h=py                                               ;h = y-Koordinate des kleinen Punktes
while h<py+fg                                                ;kannst jede Art von Schleife nehmen, hauptsache, sie läuft von py nach py+fg
  if fg-(h-py) => blockhoehe                ;liegt noch min. ein Block zwischen dem Punkt und dem Ziel?
    if block(px/20,h/20) = luft               ;wäre dieser Block passierbar?
      py+blockhoehe                            ;wenn ja, dann kann der Spieler schonmal soweit fallen
    else
      fg=0                                          ;doch aufgeschlagen? dann das Fallen beenden
      break
    endif
  else                                               ;den letzten Fallabschnitt erreicht? (Rest_fg < Blockhoehe)
    if block(px/20,(2*py+fg-h)/20) = luft ;ist der Rest passierbar? 
      py=2*py+fg-h                             ;dann nur noch um Rest_fg fallen
    else
      fg=0                                          ;ansonsten eben wieder ende
      break
    endif
  endif
  h+blockhoehe                                  ;der Punkt kann (sofern keine Kollision) weiter nach unten wandern und alles von vorne testen
wend
...

tu_wieder_blödsinn()
...
until gameend()

Statt c&p, versuch mal selbst nen Code zu schreiben

Kann sogar sein, dass bei mir noch Fehler enthalten sind, da ich zZ weder PureBasic noch viel Zeit zur Verfügung habe.

Edit: kl. Fehler bei der Umrechnung von (px,py) in Blockkoordinaten

MIB

Verfasst: **14.01.2013 19:52**

Hmmm, es funktioniert nicht. (Die pX, pY-Umrechnung habe ich schon gesehen und ausgebessert)
Zum größten Teil verstehe ich den Code auch, bis auf diesen Teil:

man-in-black hat geschrieben: else ;den letzten Fallabschnitt erreicht? (Rest_fg < Blockhoehe)
if block(px/20,(2*py+fg-h)/20) = luft ;ist der Rest passierbar?
py=2*py+fg-h ;dann nur noch um Rest_fg fallen

Wieso 2* ? Ich glaub ich bin zu blöd dafür

Verfasst: **14.01.2013 22:18**

Nachdem ich da nochmal drauf geguckt habe, kann ich nur bestätigen,
dass das nie laufen würde

(kann man den Post löschen? Is ja peinlich, was ich da verzapft hab xD)

Ich habe, fahrlässig wie ich bin, py in der Schleife schon hochgezählt, aber
an einigen Stellen wieder die alte Spielerposition haben wollen.
Kommt davon, wenn man es nur nebenher macht.

Hoffe mal, jetzt stimmt es.
Dürfte auf jeden Fall kürzer sein, als das vorherige

Code: Alles auswählen

h=py                                               ;h = y-Koordinate des kleinen Punktes
while h<py+fg                                                ;kannst jede Art von Schleife nehmen, hauptsache, sie läuft von py nach py+fg
  if fg-(h-py) => blockhoehe                ;liegt noch min. ein Block zwischen dem Punkt und dem Ziel?
    if not block(px/20,h/20) = luft               ;wäre dieser Block passierbar?
      fg=0                                          ;doch aufgeschlagen? dann das Fallen beenden
      break
    endif
  else                                               ;den letzten Fallabschnitt erreicht? (Rest_fg < Blockhoehe)
    if block(px/20,(py+fg)/20) = luft       ;ist der Rest passierbar?
      h=py+fg                                     ;dann nur noch um Rest_fg fallen
      break
    else
      fg=0                                          ;ansonsten eben wieder ende
      break
    endif
  endif
  h+blockhoehe                                  ;der Punkt kann (sofern keine Kollision) weiter nach unten wandern und alles von vorne testen
wend
py=h

Wenn wieder was komisch ist, zweifel zuerst nicht an dir selbst! Bin leider kein Genie...

MIB

Verfasst: **16.01.2013 17:45**

So langsam versteh ich es nicht mehr. Obwohl ich den Code jetzt verstehe, und dachte dass es funktionieren müsse tut es das nicht.

Wenn ich den Spieler aus unterschiedlichen Höhen fallen lasse, komme ich immer an einer anderen Höhe der Blöcke auf (meistens hört der Fall erst IN den grünen Blöcken auf).

Verfasst: **16.01.2013 21:56**

So, damit du auch mal was lauffähiges siehst, habe ich selbst was geschrieben :P

Vorweg:
-Der Code könnte sicherlich schöner/besser geschrieben werden (wollte bloß nicht zu viel Zeit investieren)
-Es ist auch mit Sicherheit nicht der beste Lösungsansatz...
-Da tauchen immer wieder "+1" und "-1" in den Berechnungen auf. Die sind nicht zum Spaß da, sondern sollen den Umstand ausgleichen,
das man ein Objekt mit gerader Pixelbreite schlecht durch den idealen Mittelpunkt beschreiben kann, sondern immer 0.5 Pixel links oder
rechts davon liegt. Bsp: OOOOXOOOOO (= 10 Pixel)
Warum ich das so genau genommen habe? Weil bei mir der Spieler genauso groß ist, wie ein Tile und es demzufolge ständig zu
ungewollten Kollisionen kommen würde.
-Nicht wundern, dass da bei den Abfragen auf Kollision scheinbar die gleichen Schrittfolgen zweimal hintereinander auftauchen.
Das liegt daran, dass ich immer BEIDE relevanten Körperecken auf Kollision überprüfe. (Wenn z.B. beim nach links Bewegen die untere
linke Ecke keine Hindernisse hat, könnte die obere Ecke ja hängen bleiben)
-Ich habe aus Zeitgründen auf Kommentare verzichtet - aber versucht, selbsterklärende Namen zu verwenden; wenn was unklar ist:
melden!

Ansonsten:
-W[S]AD

Code: Alles auswählen

InitSprite()
InitKeyboard()




Global max_x = 19
Global max_y = 19

Structure struc_tile_info
  breite.l
  hoehe.l
  *sprite
EndStructure

Global tile_info.struc_tile_info

Restore tile_info
Read.l tile_info\breite
Read.l tile_info\hoehe

Global Dim welt(max_x,max_y)

Restore welt
For y = 0 To max_y
  For x = 0 To max_x
    Read.b welt(x,y)
  Next
Next  

Global hindernis.POINT

Structure struc_spieler  
  x.l
  y.l
  *sprite
  breite.l
  hoehe.l
  fallgeschwindigkeit.f
EndStructure

Global spieler.struc_spieler

Restore spieler_pos
Read.l spieler\x
Read.l spieler\y

Restore spieler_dim
Read.l spieler\breite
Read.l spieler\hoehe


OpenWindow(0,0,100,800,600,"")
OpenWindowedScreen(WindowID(0),0,0,800,600,-1,0,0)


spieler\sprite = CreateSprite(#PB_Any,spieler\breite,spieler\hoehe)
StartDrawing(SpriteOutput(spieler\sprite))
FillArea(1,1,-1,RGB(186, 5, 5))
StopDrawing()

tile_info\sprite = CreateSprite(#PB_Any,tile_info\breite,tile_info\hoehe)
StartDrawing(SpriteOutput(tile_info\sprite))
FillArea(1,1,-1,RGB(33, 182, 12))
StopDrawing() 

Procedure Display_welt()
  
  For y = 0 To max_y
    For x = 0 To max_x
      If welt(x,y)
        DisplaySprite(tile_info\sprite,x * tile_info\breite,y * tile_info\hoehe)
      EndIf  
    Next
  Next  
  
EndProcedure
Procedure display_spieler()
  
  DisplaySprite(spieler\sprite,spieler\x-spieler\breite/2+1,spieler\y-spieler\hoehe/2+1)
  
EndProcedure  

Procedure teste_horizontale_strecke_auf_naechstes_hindernis(x1,x2,y)
  
  startblock.POINT\x = x1/tile_info\breite
  startblock\y       = y/tile_info\hoehe
  
  endblock.POINT\x = x2/tile_info\breite
  
  hindernis.POINT\x = -1
  
  If startblock\x < endblock\x 
    For x = startblock\x To endblock\x 
      If welt(x,startblock\y)
        hindernis\x = x
        hindernis\y = startblock\y
        Break
      EndIf
    Next 
  Else 
    For x = startblock\x To endblock\x Step -1 
      If welt(x,startblock\y)
        hindernis\x = x
        hindernis\y = startblock\y
        Break
      EndIf
    Next 
  EndIf
  
  ProcedureReturn hindernis
EndProcedure

Procedure teste_vertikale_strecke_auf_naechstes_hindernis(x,y1,y2)
  
  startblock.POINT\x = x/tile_info\breite
  startblock\y       = y1/tile_info\hoehe
  
  endblock.POINT\y = y2/tile_info\hoehe

  hindernis.POINT\x = -1
  If startblock\y < endblock\y 
    For y = startblock\y To endblock\y 
      If welt(startblock\x,y)
        hindernis\x = startblock\x
        hindernis\y = y
        Break
      EndIf
    Next 
  Else 
    For y = startblock\y To endblock\y Step -1
      If welt(startblock\x,y)
        hindernis\x = startblock\x
        hindernis\y = y
        Break
      EndIf
    Next  
  EndIf
  
  ProcedureReturn hindernis
EndProcedure

Procedure steht_spieler_auf_boden()
  If welt((spieler\x-spieler\breite/2+1)/tile_info\breite,(spieler\y+spieler\hoehe/2+1)/tile_info\hoehe) Or welt((spieler\x+spieler\breite/2)/tile_info\breite,(spieler\y+spieler\hoehe/2+1)/tile_info\hoehe)
    ProcedureReturn #True
  EndIf
  ProcedureReturn #False
EndProcedure  

Procedure Gravitation_spieler()
  
  If Not steht_spieler_auf_boden() Or spieler\fallgeschwindigkeit < 0
    spieler\fallgeschwindigkeit + 0.4    
    koerpery = spieler\hoehe/2
    If Sign(spieler\fallgeschwindigkeit) < 0
      koerpery * -1 + 1
    EndIf
    teste_vertikale_strecke_auf_naechstes_hindernis(spieler\x-spieler\breite/2+1,spieler\y+koerpery,spieler\y+koerpery+spieler\fallgeschwindigkeit)
    If hindernis\x = -1
      If spieler\fallgeschwindigkeit <> 0
      teste_vertikale_strecke_auf_naechstes_hindernis(spieler\x+spieler\breite/2,spieler\y+koerpery,spieler\y+koerpery+spieler\fallgeschwindigkeit)
        If hindernis\x = -1
          spieler\y + spieler\fallgeschwindigkeit
        ElseIf spieler\fallgeschwindigkeit < 0 
          If spieler\y-spieler\hoehe/2 +1> hindernis\y*tile_info\hoehe
            spieler\y = hindernis\y * tile_info\hoehe + tile_info\hoehe + spieler\hoehe/2
          EndIf      
          spieler\fallgeschwindigkeit = 0
        Else  
          If spieler\y+spieler\hoehe/2 < hindernis\y*tile_info\hoehe
            spieler\y = hindernis\y * tile_info\hoehe - spieler\hoehe/2 -1
          EndIf 
          spieler\fallgeschwindigkeit = 0
        EndIf  
       EndIf
    ElseIf spieler\fallgeschwindigkeit < 0 
      If spieler\y-spieler\hoehe/2 +1> hindernis\y*tile_info\hoehe
        spieler\y = hindernis\y * tile_info\hoehe + tile_info\hoehe + spieler\hoehe/2
      EndIf      
      spieler\fallgeschwindigkeit = 0
    Else  
      If spieler\y+spieler\hoehe/2 < hindernis\y*tile_info\hoehe
        spieler\y = hindernis\y * tile_info\hoehe - spieler\hoehe/2 -1
      EndIf 
      spieler\fallgeschwindigkeit = 0
    EndIf  
  EndIf  
  
EndProcedure  

Procedure Bewege_spieler()

  If steht_spieler_auf_boden() And KeyboardPushed(#PB_Key_W)
    spieler\fallgeschwindigkeit = -10  
  EndIf
  
  If KeyboardPushed(#PB_Key_A)
    schrittweite = 3
    teste_horizontale_strecke_auf_naechstes_hindernis(spieler\x-spieler\breite/2+1,spieler\x-spieler\breite/2-schrittweite+1,spieler\y-spieler\hoehe/2+1)
    If hindernis\x = -1
      teste_horizontale_strecke_auf_naechstes_hindernis(spieler\x-spieler\breite/2+1,spieler\x-spieler\breite/2-schrittweite+1,spieler\y+spieler\hoehe/2)
       If hindernis\x = -1
         spieler\x - schrittweite
         
       ElseIf spieler\x-spieler\breite/2 > hindernis\x*tile_info\breite
         spieler\x = hindernis\x*tile_info\breite+tile_info\breite + spieler\breite/2 -1
       EndIf
    ElseIf spieler\x-spieler\breite/2 > hindernis\x*tile_info\breite  
      spieler\x = hindernis\x*tile_info\breite+tile_info\breite + spieler\breite/2 -1
    EndIf
    
  ElseIf KeyboardPushed(#PB_Key_D)
    
    schrittweite = 3
    teste_horizontale_strecke_auf_naechstes_hindernis(spieler\x+spieler\breite/2,spieler\x+spieler\breite/2+schrittweite,spieler\y-spieler\hoehe/2+1)
    If hindernis\x = -1
      teste_horizontale_strecke_auf_naechstes_hindernis(spieler\x+spieler\breite/2,spieler\x+spieler\breite/2+schrittweite,spieler\y+spieler\hoehe/2)
       If hindernis\x = -1
         spieler\x + schrittweite
         
       ElseIf spieler\x+spieler\breite/2 < hindernis\x*tile_info\breite + tile_info\breite  
         spieler\x = hindernis\x*tile_info\breite - spieler\breite/2 -1 
       EndIf
    ElseIf spieler\x-spieler\breite/2 < hindernis\x*tile_info\breite + tile_info\breite  
      spieler\x = hindernis\x*tile_info\breite - spieler\breite/2 -1 
    EndIf
  EndIf

EndProcedure  

Repeat

  WindowEvent()
  
  ClearScreen(0)

  Display_welt()
  display_spieler()  
  
  FlipBuffers()
  
  Gravitation_spieler()
  
  ExamineKeyboard()
  
  Bewege_spieler()  
 
Until KeyboardPushed(1)

DataSection
  welt:
  Data.b      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
  Data.b      1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1
  Data.b      1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,1,1
  Data.b      1,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1
  Data.b      1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,1,1
  Data.b      1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,0,0,0,1,1
  Data.b      1,0,0,0,0,0,1,1,1,1,1,1,0,0,1,0,1,1,1,1
  Data.b      1,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1
  Data.b      1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,0,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1
  Data.b      1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
  Data.b      1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1
  Data.b      1,1,1,0,1,1,1,1,1,0,0,1,1,0,0,0,1,1,1,1
  Data.b      1,1,1,0,1,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1
  Data.b      1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1
  Data.b      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
  
  spieler_pos:
  Data.l      64,64
  spieler_dim:
  Data.l      20,20
  
  tile_info:
  Data.l      20,20
  
EndDataSection

Hoffe, das war jetzt nicht zu viel Code. Wenn doch, dann lad ich das als Datei hoch.

[EDIT: das mit dem Speichertyp gefixt; Fehler ausgebessert, um problemlos mit den Daten der Datasection rumspielen zu können]

MFG
MIB

Verfasst: **17.01.2013 15:20**

Entschuldigung dass ich dich schon wieder nerve, aber ich bekomme folgenden Error:

Code: Alles auswählen

[ERROR] Display_welt.pb (Zeile: 20)
[ERROR] Fehler beim Einlesen von Daten: keine weiteren Daten.
Das Programm wurde beendet.

PureBoard

SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?

Re: SpritePixelCollision?