Pixelmovement Terrain-Kollisionsabfrage

[Shining Advances]

das einzige was auszusetzen wäre ist, dass du das gesammte tile kopierst, obwohl du ja eigentlich nur ein pixel benötigst.
zudem übermalst du das selbe bitmap mit den 3 ebenen und fragst erst am ende ab ob das feld passierbar ist.
sofern passierbare felder weiß und nicht transparent sind, fragst du also nur die unterste ebene ab.
ansonsten kann man diverse zwischenschritte übrspringen und rechnungen durch mod verkürzen.

Code:

 def pathing_test(real_x,real_y)
    block = Color.new(0,0,0,255)#damit muss man das object/die farbe nicht 3 mal in der schleife erzeugen
    tile = RPG::Cache.tileset("PathingMap-"+@tileset_name)
    int_x = real_x / 32
    int_y = real_y / 32
    add_x = real_x % 32#damit es nicht 3 mal in der schleife ausgerechnet werden muss
    add_y = real_y % 32#siehe oben
    for i in [2, 1, 0]
      tile_id = data[int_x, int_y, i] - 384 #tileset tiles beginnen mit 384
      next if tile_id < 0 #achtung nicht 1! dadurch würdest du das erste tile überspringen
      ry = tile_id / 8
      rx = tile_id % 8 #geht mit mod einfacher und vermutlich schneller (wenn auch unwesentlich, sind ja nur kleine berechnungen)
      return false if tile.get_pixel(rx+add_x, ry+add_y) == block
      #schleife bricht ab sobald das feld nicht passierbar ist -> weniger schleifendurchläufe = weniger rechenzeit
    end
    return true#
 end

[Cornix]

das einzige was auszusetzen wäre ist, dass du das gesammte tile kopierst, obwohl du ja eigentlich nur ein pixel benötigst.
zudem übermalst du das selbe bitmap mit den 3 ebenen und fragst erst am ende ab ob das feld passierbar ist.
sofern passierbare felder weiß und nicht transparent sind, fragst du also nur die unterste ebene ab.
ansonsten kann man diverse zwischenschritte übrspringen und rechnungen durch mod verkürzen.

Code:

 def pathing_test(real_x,real_y)
    block = Color.new(0,0,0,255)#damit muss man das object/die farbe nicht 3 mal in der schleife erzeugen
    tile = RPG::Cache.tileset("PathingMap-"+@tileset_name)
    int_x = real_x / 32
    int_y = real_y / 32
    add_x = real_x % 32#damit es nicht 3 mal in der schleife ausgerechnet werden muss
    add_y = real_y % 32#siehe oben
    for i in [2, 1, 0]
      tile_id = data[int_x, int_y, i] - 384 #tileset tiles beginnen mit 384
      next if tile_id < 0 #achtung nicht 1! dadurch würdest du das erste tile überspringen
      ry = tile_id / 8
      rx = tile_id % 8 #geht mit mod einfacher und vermutlich schneller (wenn auch unwesentlich, sind ja nur kleine berechnungen)
      return false if tile.get_pixel(rx+add_x, ry+add_y) == block
      #schleife bricht ab sobald das feld nicht passierbar ist -> weniger schleifendurchläufe = weniger rechenzeit
    end
    return true#
 end

...

Vielen vielen Dank, werde ich so benutzen, aber
"#tileset tiles beginnen mit 384"
und "#achtung nicht 1! dadurch würdest du das erste tile"
treffen nichtmehr zu wenn man das erste Tile durch die Subtraktion von 383 auf 1 setzt und nicht auf 0. Ist natürlich Geschmackssache.
Außerdem hatte ich das Tile ursprünglich absichtlich überzeichnet , nur war meine Begehbar-Farbe nicht 255,255,255,255 sondern 0,0,0,0 sprich transparent. Das Tile mit transparenz zu überschreiben hätte keinen Effekt.

Edit: es funktioniert nicht, ich bekomme für jedes Tile "true" und außerdem einen Error für maximale x-, y-Werte.

Edit2: Ich habe es mit folgendem Script zum laufen bringen können:

Code:

def test(real_x,real_y)
    block = Color.new(0,0,0,255)
    tile = RPG::Cache.tileset("PathingMap-"+@tileset_name)
    int_x = real_x / 32
    int_x -= 1 if real_x % 32 == 0 # die Koordinaten (32/32) gehören noch zum ersten Tile (0/0)
    int_y = real_y / 32
    int_y -= 1 if real_y % 32 == 0
    add_x = real_x % 32
    add_y = real_y % 32
    for i in [2, 1, 0]
      tile_id = data[int_x, int_y, i] - 384
      next if tile_id < 0
      ry = tile_id / 8
      rx = tile_id % 8
      return false if tile.get_pixel(rx*32+add_x, ry*32+add_y) == block
    end
    return true
   end

die Fett geschriebenen unterstrichenen Stellen habe ich verändert.
Das Problem mit den Maximal Werten ist, dass das letzte Tile die max-X-Wert 640 und max-Y-Wert 480 was mit dem alten Script ein Tile ergeben würde welches außerhalb der Karte liegt.
Der Fehler in der Pixel-Farben Abfrage ist ziemlich offensichtlich.

[Cornix]

Ich wollte keinen neuen Thread aufmachen welcher den selben Titel trägt wie einer von mir der bereits besteht daher werde ich diesen erneut benutzen.

Mein neues Problem lautet wie folgt:
Ich versuche ein eigenes Pixelmovement System zu erstellen.
Für die Terrain-Kollision benutze ich eine art "PathingMap" sprich, das benutzte Tileset auf welchem die Map spielt ist als Schwarz-Weiß Kopie nocheinmal vorhanden, schwarze stellen sind hierbei unpassierbar, weiße können passiert werden. Soweit funktioniert alles sehr gut.
Hier ein Beispiel für diese Anfrage falls es für jemanden von Interesse ist:

Code:

def pathing_test(real_x,real_y)
    block = Color.new(0,0,0,255)
    tile = RPG::Cache.tileset("PathingMap-"+@tileset_name)
    int_x = real_x / 32
    int_x -= 1 if real_x % 32 == 0
    int_y = real_y / 32
    int_y -= 1 if real_y % 32 == 0
    add_x = real_x % 32
    add_y = real_y % 32
    for i in [2, 1, 0]
      tile_id = data[int_x, int_y, i] - 384
      next if tile_id < 0
      ry = tile_id / 8
      rx = tile_id % 8
      return false if tile.get_pixel(rx*32+add_x, ry*32+add_y) == block
    end
    return true
   end

Nun, des folgenden will ich, dass Objekte in meinem Spiel auch eine kreisrunde Kollision besitzen, sprich: Einen Kollisionsradius.
Auch der Kollisionsradius ist soweit fertig implementiert damit Objekte sich gegenseitig blocken können.

Code:

if object.collision_size < 0
      return true #air
    end
    
    if object.collision_size > 0
      for blocking_object in @blocking_objects
        if blocking_object != object 
          return false if self.collide?(blocking_object, object)
        end
      end
    end

def collide?(objectA, objectB)
    return Math.hypot(objectA.x - objectB.new_x, objectA.y - objectB.new_y) < objectA.collision_size + objectB.collision_size
  end

Wobei ich nun jedoch Probleme habe ist, diesen Kollisionsradius auch auf die Passierbarkeit des Geländes zu übertragen. Meine Gelände-Passierbarkeits-Abfrage funktioniert derzeit nur mit den x- und y-Koordinaten des Zielpunktes zu welchem sich mein Charakter bewegen will, allerdings soll auch auf dem Weg abgefragt werden ob unpassierbares Gelände den Kollisionsradius meines Charakters schneidet.
bisher kam ich lediglich auf sehr große, komplizierte Funktionen. Kennt jemand eine einfache, effektive Implementierungsmöglichkeit?

P.S.: Eine kleine zusätzliche Schwierigkeit ist, dass mein Character selbstständig wenn er auf eine unpassierbare Stelle trifft versucht das Hinderniss seitlich zu umgehen, sprich:
Wenn der Spieler die Pfeiltaste nach oben drückt und der Held auf einen Stein trifft versucht der Held nicht weiterhin geradeaus durch den Stein zu marschieren sondern nach Linksoben und anschließend auch nach Rechtsoben selbstständig aus zu weichen.

Hoffe auf weitere nützliche Beiträge der Community.
Cornix.