Minispiel-Physik

[Diamondback2007]

hallo zusammen!

ich möchte ein Spiel nachprogrammieren. und zwar folgendes: Klick

wie aknn ich die physik dazu verwirklichen? hat jemand eine idee dazu? vielleicht newton? kennt dazu jemand ein gutes tutorial?

gruß

Doppelpost im DF

[mkinzler]

ODE, Newton, ...

[Diamondback2007]

ja, an newton hatte ich auch schon gedacht, aber damit kenne ich mich nicht aus. kennt jemand ein tutorial dazu?

gruß

[mkinzler]

http://www.saschawillems.de/?page_id=82

[TheAn00bis]

"Motion Mountain"! :) -> http://www.motionmountain.net/text.html

Mein Lieblingsphysikbuch und auch noch kostenlos.

[Namenloser]

Ich glaube nicht, dass man für so ein Spiel eine Physikengine braucht. das ist ein bisschen mit Kanonen auf Spatzen geschossen. Ein bisschen Pseudophysik und das wars ;) Schließlich ist die Physik im Spiel ja auch nicht gerade realistisch. :mrgreen:

Ich habe mal eine kleine Zecihnung angehängt, wie ich das machen würde.

[Diamondback2007]

Zitat:

Zitat von NamenLozer

Ich glaube nicht, dass man für so ein Spiel eine Physikengine braucht. das ist ein bisschen mit Kanonen auf Spatzen geschossen. Ein bisschen Pseudophysik und das wars ;) Schließlich ist die Physik im Spiel ja auch nicht gerade realistisch. :mrgreen:

und wie sollte diese pseudophysik deiner meinung aussehen? ich hab von physik in spielen nämlich überhaupt keine ahnung und auch keine erfahrung;)

zu dem buch: ich habe es mir mal runtergeladen und werde es mir mal anschauen. :)

gruß

[brinkee]

Naja, ein bisschen Mechanik halt.

v = a * t
s = 0.5 * a * t^2

und das war's auch schon. Ein bisschen Newton'sche Axiome und das war kein Hexenwerk. So kann man recht leicht berechnen, wie weit das Teil fliegen muss. Man kann es mit der Erdbeschleunigung fallen lassen... Aber Eigentlich brauchst Du dafür nur ein bisschen Sinusse und Cosinusse, da Du eigentlich nur Geschwindigkeitsvektoren miteinander verrechnen musst. Die Beschleunigungen sind eigentlich unwichtig.

LG, Markus

[Diamondback2007]

okay die gleichungen kenn ich ja aus physik ;) aber was nehme ich als zeit? die differenz zwischen den frames?
und wie kann ich die kollision mit dem boden realisieren? also die abfrage nach einzelnen pixeln dürfte ausscheiden bei oder?

vielen dank! :)

gruß

[Namenloser]

Du könntest ein Polygon benutzen und dann mit PointInPoly prüfen:

Delphi-Quellcode:

Function PointinPoly(points:array of Tpoint;nrpoints:Integer;tp:Tpoint):Boolean;
var hnd:hdc;
BEgin
hnd:=CreatePolygonRgn(points,nrpoints,Winding);
Result:=PtInRegion(hnd,tp.x,tp.y);
DeleteObject(hnd);
end;

Und wie gesagt, bei der Physik würd ich mir nicht so viel Arbeit machen. Bei der Beschleunigung bergab bzw. der Verlangsamung bergauf würde ich einfach ein bisschen rumexperimentieren bis es passt. Und außer Beschleunigen, Bremsen und Springen gibt es in dem Spiel ja auch nichts, oder? Beuschleunigen und Bremsen dürfte jedenfalls kein Problem sein und Springen eigentlich auch nicht.

//edit: @0,375: Uppsi, äh ja meinte ich^^

[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:

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:

Zitat von Diamondback2007

dadurch werden die berechnungen natürlich sehhhr ungenau

Wie Billi schon schrob (bzw. ich ihn interpretiert habe :stupid: ), 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. :cheers:

[Khabarakh]

Zitat:

Zitat von Diamondback2007

bei Integer sieht das ganze etwas ruckelig aus ;)

Eben, deswegen nimmst du direkt die Daten aus dem Array und nicht erst die visualisierten.

Zitat:

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. :)

Öhm, nein, das habe ich eigentlich nicht gemeint :gruebel: . Ich wollte sagen, dass du jetzt nicht mehr wie mit der VCL "bitmap.Canvas.DrawLine" sondern "bitmap32.LineFS" (bei beiden Codebeispielen bitte noch "oder so ähnlich" anhängen) benutzen musst, um rationale statt ganzen Koordinaten anzugeben.

[Progman]

mann kann immer die Berechnungen mit Float durchführen, nur vor dem Zeichnen muss man Round() aufrufen. Ist doch auch logisch. Die Pixel auf dem Bildschirm sind schließlich auch Integer. Es gibt nun mal keine halben Pixel ;)

[Diamondback2007]

also ich fasse mal zusammen:

-meine leveldatei besteht aus einem dokument in dem "eckpunkte" meines levels stehen.
das heißt alle punkte an er sich die y-achse verändert. diese punkte liegen in abschnitten in dem
dokument -->bessere performance

-meine visualisierung mach ich mit graphics32. und zwar zeichne ich meine frames in einen buffer und
dann auf mein canvas(hierzu noch eine frage: soll ich auf ein canvas der graphics kompos zeichnen?bringt mir
das performace im gegensatz zum form canvas?)

-Die physik werde ich mit den mechanikgleichungen bearbeiten. (Auch hier noch eine frage: ich habe einen timer
im moment, in dem ich meine gleichung wegdifferenz = 0.5*9.81*t² berechne. diese dient im moment für die erdanziehung.
nun muss mein wagen aber ja springen können. wie soll ich das machen? das passiert natürlich mit der selben gleichung.
aber wie soll ich die in mein programm implementieren? noch ein timer, der bei bedarf anspringt? welche beschleunigung
soll ich wählen?das ist mir doch vollkommen frei oder?(außer halt größer als 9.81 ;) ) die differenz wird dann halt vom
y-wert abgezogen, das stimmt doch so oder?)

-im anhang findet sich ein kleines bespielprogramm welches ich schnell geschrieben habe. hier wird die problematik mit
den timern deutlich.

vielen dank :)

gruß

[Progman]

Hi, ich hab mir die Demo mal angesehen. So würde ich es nicht machen.
Schau mal in den Graphics32-Beispielen in die Demo "Layers". Dort kannst du sehen, wie man sowas realisiert.
Schau die das mal an. Das habe ich mit Layers gemacht.
Das heisst:
Der Hintergrund ist ein TImage32, die Erdkugeln sind Layers, die sich frei positionieren, einblenden und ausblenden lassen. Die Grafiken dazu werden beim Start in eine TBitmap32List geladen. Die Laderoutine hab ich übrigens 1:1 aus der Layers-Demo übernommen ;)
Ich glaube, nach diesem Prinzip kann man durchaus so ein kleines Spiel, wie du es möchtest, machen.

[Sidorion]

Also ich hasse ja normalerweise solche Posts wie: 'Warum das Rad neu erfinden, nim diesunddas', aber bei Graphikdarstellung mit Canvas rumfrickeln ist doch ein bisschen naja. Nimm eine Graphikbibliothek, die nimmt Dir das ganze Gewurschtel ab. Zudem kriegst Du Layer, Transparenz, gedrehte Bildchen uws. gratis dazu und hardwarebeschleunigt isses auch noch. Hierzu fällt mir ein seht gutes Tut hier ein.

[Progman]

@Sidorion:
Ich geh davon aus, dass es sich hier um einen Anfänger (was Grafik-Programmierung betrifft) handelt.
Und den gleich ins OpenGL zu schubsen, ist wohl nicht grad optimal.
Ich denke, wenn er mal paar einfachere Sachen fertig gestellt hat, wird er selbst zu dem Schluss kommen, sich mal mit Engines zu befassen ;)

[3_of_8]

Ich war auch noch Anfänger, als ich mit OpenGL angefangen hab, und ich habe es nicht bereut. Zur Not kann man auch DelphiX verwenden, das ist nicht ganz so kryptisch.

[Sidorion]

Ganz im Gegentum. 1. wird einem mit einer Bbliothek so ziemlich alles, was Zeichnen heisst abgenommen, er muss sich sozusagen nur mit der Mathematik(Physik) beschäftigen und 2. sieht er wesentlich schneller Resultate, die dann wahrscheinlich auch auf Anhieb besser aussehen werden.

Es ist doch wesentlich einfacher, einer Bibliothek su sagen: Zeichne ein um 30° gedrehtes Viereck mit diesem Bild an jene Stelle, als die Bitmaps irgendwie im Speicher zu rotieren und die Rastepositionen, Transparenzen usw. selber zu berechen.

Wie Du schon sagtest: Er wird selber zu dem Schluss kommen... Wenn man sich ber diese Mühen ersparen will, kann mans auch gleich ordentlich machen.

p.s.: 3_of_8: Delphix ist keine ordentliche Graphikbibliothek und die Einarbeit hier ist genauso sinnvol, wie alles selber Zeichnen wollen.

[Diamondback2007]

Zitat:

Zitat von Progman

@Sidorion:
Ich geh davon aus, dass es sich hier um einen Anfänger (was Grafik-Programmierung betrifft) handelt.
Und den gleich ins OpenGL zu schubsen, ist wohl nicht grad optimal.
Ich denke, wenn er mal paar einfachere Sachen fertig gestellt hat, wird er selbst zu dem Schluss kommen, sich mal mit Engines zu befassen ;)

also... ;) ich bin kein grafik anfänger und ich wollte eigentlich nur wissen, wie ich das ganze realisieren soll, weil ich keine lust hatte für eine so simple grafik eine engine zu nutzen ;)
Das hier ist mein derzeit größtes projekt.
aber ich denke ich werde dies doch tun. auch wenn ich dann wieder alles selbst programmieren muss wie z.b. die events. ist zwar ärgelich aber egal ;)
hier direkt OGL in reiner form zu benutzen halte ich für unnötig ;)
OGL an sich hab ich schon gelernt.
also ich denke ich werde meine altbekannte "fear2d-Egine" nehmen und damit sollte das funktionieren.

hat jemand eine idee wie ich das mit der sprungkraft machen soll?so wie ich es in der demo gemacht habe ist wohl nicht so optimal... :stupid:

gruß

EDIT: also von DelphiX kann ich auch nur abraten ;) mir hat es überhaupt nicht gefallen :|