PureBoard

Ich wollte ein Jump'n Run programmieren und habe ein nettes (lang scriptiges) Startmenü auf die Beine gestellt.
Jetzt wollte ich mit dem eigentlichem Spiel beginnen und habe auch schon den Übergang auf einen Hintergrund (ganz normales Bild) hingekriegt.
Jetzt wollte ich fragen: Wie schafft man es Gegenstände einzufügen, auf dem der Held stehen kann?
Und wichtiger noch: Wie schafft man es, dass der Computer weiß was vor bzw. hinter der sehbaren Bereich ist. Also wie ein Streifen aus dem der immoment sehbare Bereich ausgeschnitten ist und man wenn man an den rechten oder linken Rand kommt, den Sehbaren Bereich nach rechts oder links verschiebt.

P.S.: Danke für jede (sinvolle) Antwort im Vorab.

das level baut man normalerweise aus einzelnen kleinen elementen zusammen (tiles). am besten suchst du erstmal generell nach tutorials zum thema tilemapping.

welcher bereich von der karte grade sichtbar ist, läßt sich mit grundschul-mathematik feststellen: dein screen hat eine besstimmte auflösung, zb 640*480, 800*600 usw. deine tiles haben eine bestimmte breite und höhe, zb 30*30 oder 64*64 oder ...

es kann nur ein bestimmter teil des levels sichtbar sein wenn dieser größer als der screen ist, also hat der screen eine position in deiner karte.

nehmen wir mal an, deine karte ist 1000*1000 tiles groß, bei einer tilegröße von 20*20. dann ist dein level 20000*20000 pixel groß. nehmen wir mal an, dein screen ist grade an position (in pixeln) x=531, y=312. weiterhin nehmen wir an, dein screen hat die diemension 640*480.

dann sind die tiles von (513/20=25,65 , 312/20=15,6) bis (25+(640/20)+1, 15+(480/20)+1) sichtbar.

Danke für die Antwort!

P.S.: Aber woher bekommt man ein gutes Jump'n Run Tutorial.
Habe schon ein bisschen gesucht aber keins gefunden.

eine sehr kurze suche führte mich dahin: http://jnrdev.72dpiarmy.com/

keine ahnung wie gut die sind.

Also immer wenn ich Jump and Runs gemacht habe hat es irgendwann in einem absoluten Chaos geendet. Gibt es Tipps wie man in PB Strukturierte Jump and Runs baut?

Es gibt höchstens Tipps, wie man generell ein Programm strukturiert. Davon allerdings eine ganze Menge.

Die imho wichtigsten:
- Erst Denken, dann Programmieren (das machen sehr wenige leute)

- im Programm erkennbar benannte Konstanen und Variable verwenden, statt irgendwelche Zahlen in den Code zu müllen

- Globale Variablen nur da verwenden, wo sie sich entweder nicht vermeiden lassen oder einen großen Geschwindigkeitsgewinn bedeuten

- Einrückung und Leerzeilen sinnvoll verwenden. Einrückung sollte Programmstruktur wiederspiegeln, Leerzeilen sollten zusammengehörige Elemente gruppieren den Code aber nicht zu sehr "verdünnen".

Danke Zaphod.
Ist zwar ne Englische Seite (da habe ich nicht gesucht aber was solls) aber trotzden genauso nützlich wie eine deutsche.

Ich denke mal das ich das Tutorial benutzen kann.
Da steht zwar das es in C++ verfasst ist, scheint aber Pure Basic zu sein.

P.S.: Habe jetzt auch eins gefunden. Denke mal ich kann von beiden was lernen. DANKE!!!

Habe letztes Jahr auch mal eine Jump'n'Run-Engine angefangen, ist zwar noch nicht sehr weit gekommen aber man konnte immerhin jumpen und runnen

Weiß nicht, was Deine Tutorials sagen, aber Du könntest z.B. erstmal anfangen, etwas zu programmieren, wo Du die Spielfigur über ein Gelände mit Mauern VON OBEN GESEHEN steuerst, inkl. Scrolling usw. Das ist erstmal einfacher. Wenn Du das hingekriegt hast, kannst Du quasi Schwerkraft einbauen, so daß die Figur nur noch links und rechts steuerbar ist und immer nach unten fällt bis zu einem Hindernis. Dann werden die Wände zu Plattformen. Nun fehlt nur noch, daß die Figur springen kann, und Du hast im Prinzip ein Jump'n'Run

Bei mir lief das auch so ab, hab ein Spiel für 'nen Contest programmiert (Maze Mission, kannst ja mal suchen), welches auch von oben gesehen ablief, das hab ich dann hinterher einfach zum Jump'n'Run umgebaut.

Wenn Du irgendwie Fragen hast kannst Du mich gern kontaktieren.

Ich hab da noch ne frage
Wie kriegs ich hin,dass soch die Kamera weiterbewegt??

Inwiefern meinst Du jetzt?

In meinem Fall war es so, daß ich einfach die Spielfigur immer genau in der Mitte des Bildschirms angezeigt hab. Alles andere hat sich dann relativ zur Spielerposition verschoben.

Es gibt aber auch Spiele (bzw. das sind sogar die meisten), wo man einen gewissen Hin- und Herlaufbereich hat, und erst ab einer gewissen Position scrollt der Hintergrund dann mit und die Figur bleibt an dieser Position stehen. Das fand ich zu dem Zeitpunkt grad etwas kompliziert bzw. ich war zu faul, aber auch das sollte nicht gerade ein großes Problem sein.

~

Mal noch ein konkreteres Beispiel. Du hast die PlayerX und PlayerY. Den Player selbst zeichnest Du immer genau in der Mitte, also völlig unabhängig von X und Y. Nehmen wir an Du hast eine Auflösung von 320x240 und Deine Figur ist 40x40 groß, dann wäre die Position 140|100 (wobei ich statt 100 dann doch eher 120 oder 130 sogar nehmen würde, weil es cooler aussieht wenn die Figur nicht allzu weit oben ist).

Alle anderen Koordinaten, z.B. die eines Tiles oder eines Objekts, berechnest Du so:
Nun programmierst Du das Spiel natürlich so, daß bei Tastendruck sich die PlayerX und PlayerY Werte ändern, und dann sollte es eigentlich perfekt funktionieren. Wenn Du dann noch einbauen willst, daß Du eben einen gewissen Spielraum hast, bevor der Hintergrund zu scrollen anfängt, mußt Du erstmal 'ne Weile Mario und Co. zocken, schauen, wie die das so gemacht haben, dann entscheiden ob Du das auch willst und dann den Code entsprechend anpassen.

EDIT: Ach ja, mein Ansatz wäre (hab aber nie großartig drüber nachgedacht), zusätzlich CameraX und CameraY zu verwenden, wobei sich diese nur ändern dürfen, wenn PlayerX und PlayerY zu stark davon abweichen. Läuft der Typ also rum, ändert sich die Player-Position, und wenn z.B. PlayerX 50 Pixel größer oder kleiner als CameraX ist, verändert sich auch CameraX. Gezeichnet wird dann natürlich auch entsprechend nach CameraX und nicht nach PlayerX. Auch der Player wird dann vom Zeichnen her eben wie alle anderen Objekte auch behandelt.