Minispiel-Physik

[3_of_8]

Du meinst ein Polygon, oder?

Der korrekte Weg ist so: Man nimmt sich die Erdbeschleunigung (9,8m/s²) und zerlegt sie in Zugkraft (sin alpha * 9,8m/s²) und Normalkraft (cos alpha * 9,8m/s²), wobei alpha der Steigungswinkel deiner Strecke ist.

Das ist dann realistische Physik. Ob du dem Spiel eine etwas "unrealistischere" Physik geben willst, um es besser spielbar zu machen, musst du entscheiden. Das wird oft gemacht, zum Beispiel in Shootern, in denen man in der Luft noch seinen Landepunkt verändern kann oder in Rennsimulationen, in denen man das Auto in der Luft noch nach links und rechts drehen kann.

[Billi Berserker]

Wie bereits gesagt ist dafür wirklich keine komplette Physik Engine nötig
Das wäre viel zu viel!

Zum Thema Kollisionsabfrage, du hast dann ja irgendwie die Daten des levels gegeben (wo sind Schienen, Hindernisse, etc.). Die Abfrage zur Kollision würde ich einfach über 3 Punkte des Waagens realisieren (Vorne, Mitte, Hinten - oder 2 Punkte, die Räder). Du überprüfst einfach nur die Y-Komponenten. Wenn das ding noch irgendwie mit Objekten vorwärts zusammen stoßen kann dann würd ich vorne und hinten auch noch Kollisionspunkte dran hängen.

[Diamondback2007]

also soll ich dann im prinzip jeden pixel meier welt aufschreiben und dann überprüfen?
das ganze dann am besten in bereiche eingeteilt um zu große schleifen zu vermeiden?

gruß

[Namenloser]

Hi,

also ich beschäftige mich momentan auch mit diesem Zeug, weil ich plane eine Sonic (the Hedgehog)-Engine zu programmieren. Dort will ich es so machen, dass ich das Level in etwa 100x100 große Kästchen einteile, in denen jeweils vermerkt ist, welche Objekte (in deinem fall eben die Linien auf der Oberfläche des Bodens) darin liegen. Diese Objekte würde ich dann noch mal genauer prüfen. Ich denke, dass sich damit die Performance unter Umständen beträchtlich erhöhen lässt.

Vielleicht kannst du es ja so ähnlich machen.

[Diamondback2007]

ja das sehe ich genauso. über die größe de einteilung muss man einfach mal experimentieren.

zum thema visualisierung:denkt ihr eine reine VCL-Programmierung würde dazu ausreichen, oder soll ich das ganze wieder in eine Engine verpacken?

[Billi Berserker]

Zitat von Diamondback2007:

also soll ich dann im prinzip jeden pixel meier welt aufschreiben und dann überprüfen?
das ganze dann am besten in bereiche eingeteilt um zu große schleifen zu vermeiden?

gruß

Du hast doch sicherlich nur eine "Schiene" auf der du rum fährst. Da wirst du doch für jeden X-Wert irgendwie den passenden Y-Wert wo die Schiene ist speichern können. Ist dein Waagen drunter stimmt was nicht

Zur Visulisierung würde ich mal graphics32 versuchen.

[Diamondback2007]

okay ich habe mir mal graphics32 runtergeladen allerdings gib es ein problem. auch bei diesem Image sind die koordinaten vom typ integer...dadurch werden die berechnungen natürlich sehhhr ungenau...weiß jemand abhilfe?

gruß

[Khabarakh]

Du hast dir wahrscheinlich die Funktionen von TBitmap32.Canvas angeschaut. Schau einmal direkt im Bitmap, da wirst du Funktionen wie Line, Pixel, ... mit etlichen Suffixen finden, die dir alle Wünsche erfüllen werden. Näheres zu den Suffixen natürlich in der Hilfe .

[edit]

Zitat von Diamondback2007:

dadurch werden die berechnungen natürlich sehhhr ungenau

Wie Billi schon schrob (bzw. ich ihn interpretiert habe ), brauchst du hier keine Pixelkollision. Du legst die einzelnen Streckenabschnitte einfach in ein Array oder Ähnliches und kannst dann für jeden beliebigen X-Wert den Y-Wert berechnen. Jedenfalls solange du keine Loopings oder Ähnliches einbaust .
[/edit]

[Diamondback2007]

genau Y-werte benötige ich für die berechnung von beschleunigung und erdanziehung und sowas
bei Integer sieht das ganze etwas ruckelig aus

mit Bitmap meinst du also ich soll einfach ein bitmap verschieben anstatt eines TImage32? das wäre natürlich eine idee wenn wie positionen davon real sind.

gruß

[Namenloser]

Du solltest Besser keine Images verschieben, sondern selber zeichnen. Spätestens bei der Transparenz wird's sonst nämlich kritisch, aber auch die Performance dürfte eine Rolle spielen.

Die Graphics32-Bibliothek bietet eine Menge Funktionen, um Bilder gedreht verzerrt oder sonstwie zu zeichnen. Du brauchst für jeden beweglichen gegenstand ein TBitmap32, z.B. für den Wagen. Diesen Wagen (und die anderen Gegenstönde) zeichnest du dann im richtigen Winkel gedreht auf einen Buffer, der so groß ist wie dein fenster und ebenfalls ein TBitmap32 sein sollte. Diesen Buffer kopierst du dann noch auf das Canvas des Formulars, und fertig ist der Frame.