Ich kann Dir natürlich nicht die ganze Konzeption des Spiels schreiben.
Ich habe mal eine Version von Zuma rauf und runter gespielt, weshalb ich weiß, wie es geht, mehr nicht.

Mit Pfaden habe ich noch nie gearbeitet. Da müsstest Du im Handbuch unter Path Funktionen nachschauen.

Ich würde bei der Schusskugel immer eine Kugellänge vor ihr überprüfen, was dort ist. Und dann überprüfen, welche Kugel vom Pfad aus gesehen weiter vorne liegt.

Für das Rollen der Kugeln würde als Animation erstellen, die Kugel immer entsprechend ihrer jeweiligen Pfadposition ausrichten und entsprechend der zurückgelegten Strecke die Animation abspielen. Ich habe gestern grad in Workshop 25 zum Multiplayer gleich am Anfang diese Art der Behandlung einer Animation gesehen.

danke ich versuche mal weiter

Im Grunde brauchst Du weder WED Pfade, Events oder ent_move.

Überleg Dir erst mal auf Papier wie man eine
"Schlange" aus einzelnen Linien zieht. Also quasi
einen eigenen Vertor-Pfad aus einer Reihe von
x,y Punkten.
Das ist der Weg den die Kugeln nehmen.

Danach versuch mal die Länge des Pfades zu berechnen.
(Phytagoras einer Linie ist die Länge eines Einzelstückes,
die Summe der Linien ist die Gesammtlänge)

Dann versuch mal einen Punkt zu finden, der eine bestimmte
Länge vom Anfang des Pfades entfertn ist.
(ist komplizierter, schau mal nach dem Dreisatz um die Posiition
auf der Linie zu berechnen)
(das ist die Position der Kugeln)

Dann hast Du zumindest schon die Basis, wie man Kugeln
entlang eines Pfades Bewegt.
Die Entfernung vom Anfangspunkt, ist der einzige Parameter
die die Kugel wissen muß, um eine x,y position zu berechnen.

Soviel zur ersten hausaufgabe.
Im weiteren mußt Du dann definieren, wie die Kugeln sich
gegenseitig in der Reihe bei Bewegungen beeinflussen.
(eg, eine Kugel berührt eine andere, wenn der abstand
der beiden x,y Koordinaten kleiner, gleich dem Durchmesser einer Kugel ist.)

Ich hab vor 2 Jahren ein Zuma Spiel für Handies geschrieben,
kenn mich also mit der Grundmechanik aus.

---

Du kannst natürlich auch versuchen alles mit der Physikengine zu realisieren.
Die Frage ist aber wie Fehleranfällig das ganze dann wird.

@ Damocles

irgendwie weiß ich nicht ganz weiter: also ich habe jetzt einen pfad aus einzelnen linien auf nem blatt papier gezogen, den, den die kugeln nehmen sollen (ist doch richtig: einen pfad aus vielen geraden linien ziehen und die kurven auf aus mehreren geraden linien machen,oder?

und was soll ich jetzt machen? soll ich nun alles zusammenrechnen also jetzt einezelne gerade linie addieren. in cm oder was?das wären dann 29.9 cm auf meinem papierchen. und was soll ich damit jetzt anfangen? irgendwie checke ich das nicht.

könntest du das bitte noch mal erklären (so das ich es auch verstehe). wäre echt nett. danke schon mal im voraus. ích stehe da irgendwie auf dem schlauch.

Ja, Du solltest nur Linien nehmen (Bezirkurven und ähnlicher Schnickschnack ist overkill) für die Rollstrecke.

Die Maßeinheit ist egal.

Im Endeffekt willst Du warscheinlich Quants als x,y position nehmen.
(die Z position ist dann ein fester wert im Späteren 3D Level
für die Kugeln)

Auf dem papier kann man erstmal die Berechnung üben.
Später kannst Du die Koordinaten der Linien-Punkte zB in WED bestimmen (entlang der Roll-Strecke), wenn Du ein Level gebastelt hast.
Wie Groß Du das im Level skalierst ist eigendlich egal.
(Du mußt nur aufpassen wenn Du mit Var rechnest, das du
keine zu großen Zahlen multiplizierst. Ist eher ein technisches Detail)

Mach zB einfach eine Testkugel, 20 Quants groß, und bau ein
Testlevel in WED, mit der gewünschent Laufstrecke.
Dann kannst Du die Verbindungspunkte (x,y) entweder in WED "abschreiben"
und in den Code Schreiben, oder (eleganter) Hilfobjekte
setzen, oder die Path-Funktionen benutzen.

Im Endeffekt muß die Liste an x,y Koordinaten im Programm
verfügbar sein (wie auch immer es eingelesen wird).
Sie definiert die Rollstrecke und somit die möglichen Positionen der Kugeln.

Wenn Du es erstmal schafft eine Kugel entlang der Rollstrecke
"laufen" zu lassen (Entfernung vom Anfang erhöhen -> neue x,y Position berechnen), ist schonmal ein großer
Teil der Mechanik im Kasten.


Edit:
Zur Berechnung der Position:

gegeben:
Pfad (liste an x,y Positionen)
Entfernung der Kugel von Anfangsposition
gesucht:
x,y Koordinate der Kugel

Vorgehensweise:

Berechne Abstand der ersten Position zur folgenden.
(Phytagoras, oder vec_dist )
Addiere die Länge zum Abstandscounter.

Widerhole das bis der Abstandscounter größer ist
als die Entfernung der Kugel vom Anfang.

Jetzt kennst du die beiden position zwischen denen die
Kugel liegt.

Dann:
Abstandscounter - EntfernungKugel = Abstand der Kugel vor der letzten Position.
Berechne die x,y position der Kugel mit hilfe
der x,y positionen der beiden Enden der Linie und dem Abstand zum Endpunkt der Linie
(Dreisatz -> Wikipedia)

Gfunden:
x,y Position der Kugel


---------------

oh, Ich seh gerade im Manual:
path_spline(ENTITY*,VECTOR* pos,var dist)

Schau dir das mal an, das sollte die Pfadberechnung
Vereinfachen.
(hab nach nie die Pfadfunktionen benutzt)

tut mir leid, also ich checke das einfach nicht. ich weiß absolut nicht was ich jetzt machen soll... ich habe einen hohlen würfel in wed erstellt. und was soll ich jetzt machen.

punkte ermitteln? wie denn? und was für punkte?

ich glaub ich bin einfach zu dumm dafür.....?!
anscheinend muss ich jetzt doch mal um etwas code betteln. könntest du nicht einen ausschnitt, wie das sein müsste hier rein posten? ich komme total nicht weiter...
ich hoffe ich nerve dich damit nicht allzusehr aber ich beschäftige mich noch nicht sehr lange mit lite-c daher bin ich bei einigen sachen noch nicht so erfahren und weiß dann auch nicht direkt auf anhieb was da zu tun ist.

danke aber totzdem für deine mühe und für deine antworten.

PS: vllt. kannst du mir hier ja noch ein wenig helfen.

lg
Robin

Also Code schreiben werd ich jetzt nicht.
Den kann ich ja nicht hinkloppen, sondern müßte den erst erstellen und testen...

Warum schiebst Du nicht das Zuma Projekt erstmal nach hinten,
und versuchst ein einfacheres projekt für den Anfang.

Casual Games sehen oft simpel aus, aber im Grunde
steckt da viel Abstakte Mechanik hinter, bei denen
die netten Enginefunktionen nicht viel helfen.

Noch ein Rat: Du solltest erstmal die Spielmechanik auf
dem Papier entwickeln und verstehen.
Erst danach solltest Du dir überlegen wie es in der speziellen Engine implementiert werden muß.
Und dann versuchst Du das schrittweise umzusetzen.
(wie zB Hier, eine Kugel entalang eines Pfades zu bewegen)

ich denke ich werde es auch erstmal etwas verschieben und einfach mal so ein wenig rum probieren. ich schiebe dann mein zumaprojekt etwas auf. und versuche es mit casual games