4. 2d shooter - ernste frage

2d shooter - ernste frage

  • F

    hallo
    da ich ein grosser fan von 2d shooter bin und auch programmieren kann, würd ich gern so ein game machen.

    Da ich bis jetzt nur MFC Dialogbasierte Programme entworfen habe, und noch kein Game gemacht habe, ist die Frage wie ich das am besten mache.

    Ich hab .Net als Umwicklungsumgebung. Portablilität ist nicht so wichtig. Soll auf Windows Rechner laufen. Code in C++ sein.

    Was muss ich beim Assistenten auswählen.

    SPIELPRINZIP:

    2D Shooter aka

    - 1943,1945
    - Strikers 1945 Plus

    Also wo man von unten nach oben fliegt.

    -- VORÜBERLEGUNGEN: --

    Scrooling:

    z.b. mit verschiedenen Bmp ( jpeg ) arbeiten. Sprich z.b. 800 * 600 Bilder. Davon ungefähr 20-3ß Stuck am Anfang pro level.

    Sichtbarer Bereich 800*600 dann z.b. alle x milisec ( ms ) das "erste" Bild z.b. 50 Pixel nach unten "verschieben" und dann vom 2weiten Bild 50 Pixel oben anzeigen. Ist ja sogesehen kein problem.

    Flieger:

    Flieger ( 3 Bilder ) 1 Bild normaldarstellung. 2 Bild "schwenkt" nach rechts zeichnung 3 bild schwenk nach links zeichung

    Am Anfang den Flieger darstellen der sich in 8 Bewegungen steuern lässt.
    Dann Joypad alle x ms abfragen und dann z.b. 5 Pixel in xy Richtung neu "malen".

    Dann kann man wenn man gerade nach links drückt dann 3 bild malen. wenn gerade nicht drückt. Bild gleiche position malen und bild 1 nehmen.

    Feinde:

    Bei den Feinden ähnlich wie mein Flieger, nur halt angriffswellen programmieren wie sie kommmen.

    Kugeln:

    Eigene Kugeln. Wenn man vorne drückt bewegt sich flieger z.b. 10 Pixel weiter oben. kugel muss dann z.b. aber min 11 Pixel ( besser 15-20 ) weiter oben gezeichnet werden.

    bei den feinden genauso. Aber 2 arten

    1. vorberechnete ( statische ) sprich kugeln haben feste route
    2 "dynamische" sprich zum zeitpunkt des abschusses werden diese in richtung flieger geschossen ( z.b. man nimmt mittelpunkt-Pixel vom flieger als ziel )

    Explosionen:

    Feststellen wann sich die "rand" pixel des fliegers mit den randpunkten der kugeln oder feinden treffen. dann werden z.b. 3 bilder geladen die dann "flüssig" die explosion darstellen. dann werden die leben dekrementiert.
    wenn keine leben dann halt andere musik abgespielt ect.

    bei feinden gleich.

    Abfragen:

    a ms werden knöpfe abgefragt.
    b ms werden flieger und feinde dargestellt
    entweder b oder c ms werden kugeln dargestellt
    d ms wird dan neue hintergrundbild dargestellt

    zu a: ein knopf kann man normalerweise in einer sec max 6-8 klicken d.h. abfrage z.b. alle 0.1 sec ( dass man halt nichts verpasst )

    --FRAGEN:--

    wie mache ich das am besten? Gibts da eine komfortable engine oder muss man alles selber machen? Wie heisst die Anwendung dann für .net

    Welche klassen brauche ich da?

    gibt es da klassen die z.b. direkt auf das pad zugreifen + tastatur? ( ok gibt es aber wie heissen diese)? tut das BS meinem proramm mitteilen wenn was gedrückt wird oder muss ich selber abfragen? und dies damit steuern? wie macht man dies am besten?

    Bei den Bild "verschiebungen" siecht das gut aus oder wird nach meinem Prinzip alles ruckeln?

    Bei .net gehen ja glaub nur 50ms gut, weil kein echtzeit Betriebssystem. reicht dies dann alles aus?

    soll ich die Bilder komplett zeichnen und dann so verschieben oder ist es besser einzelne Frakmente zu zeichnen die dann zusammengefügt werden. z.b. 60% wasser. d.h. z.b. 40mal das gleiche mini bild ( 10*10 Pixel ) verwenden.

    Welche Methode ist besser? Gibt es da auch gute Klassen?

    So das wars fürs erste. Ich hoffe es kennt sich jemand aus und kann mir helfen.

    Dank im voraus.

    PS: wie findet ihr so die grundidea?

    0
  • M

    so... also, du barauchst erstmal eine API, zum beispiel die SDL, die ist glaub ich gut geeignet für 2D-Scahen, oder schau dir maol Allegro an.

    So, wie das mit Eingabe in SDL ist, weiß ich nciht.
    Aber generell:
    Man macht es normalerweise nciht so, dass man alle x ms mal etwas zeichnet / abfragt usw...
    Sondern man hat eine große Spielschleife, (bei win die Nachrichtenschleife). Diese wird so oft durchlaufen wie ncur möglich und bei jedem Durchlauf wird dann alles gezeichnet, abgefragt usw.
    Die bewegungen müssen dann noch mit der Zeit, die seit dem letzten Frame vergangen ist, multipliziert werden, damit es auf alen PCs gleich schnell läuft. Ansonsten, schau dir mal Beispiele von SDL-Proggies oder so an, die sind ja glaub ich (fast) alle OpenSource.

    0
  • T

    Die Spiellogik mit fester Framerate laufen zu lassen, hat aber auch sehr große Vorteile. Vor allem bei physikalischen Berechnungen, die sich so leicht nicht auf kleinere Zeitabschnitte skalieren lassen.

    0
  • ?

    Wenn du nur MFC bisher gemacht hast, dann darfst du dich jetzt erstmal mit einer Grafik-API auseinandersetzen.
    Und dann brauchst du (wie mir scheint) dringend ein Tutorial über Timing und Scrolling.

    EDIT: omg, 3 Posts in weniger als einer Minute ;((

    0
  • B

    *g*... der Entwurf ist in den groben Zuegen gut, aber du wirst noch waehrend des Projekts draufkommen, dass es noch einige vor allem implementierungsspezifische Probleme gibt, die du noch nicht bedacht hast, z. B.

    * wenn der Gegnermittelpunkt bei 30/30 ist, eine Kugel auf 30/15, und die Kugel macht 15 px/frame, der Gegner 5 px/frame, dann fliegt die Kugel durch den Gegner durch, ohne ihn zu treffen!

    * Wie willst du die ganzen Kugeln verwalten?

    * wie willst du die Angriffswellen dynamisch machen?

    * etc.

    aber wie gesagt, dass ergibt sich waehrend des Programmierens alles noch, die bisherige Planung ist ganz ok denk ich 🙂

    Ob und wie man das Ganze mit .net machen kann, kann ich dir nicht sagen, normalerweise verwendet man dafuer eigene (Grafik)-Libraries, z. B. libSDL (www.libsdl.org), Alegro usw.... aber Prinzipiell ist das ganz sicher auch mit MFC machbar 🙂

    0
  • F

    ok danke danke dann schau ich mir mal die 2 sdl's an.

    naja ich dacht das es maybe eine klasse gibt die die objekte verwaltet und wenn diese sich treffen ( sprich meine randpixelpunkte auf die treffen vom feind ) wird ein "ereignis" ausgelöst.

    natürlich ist die sache dann so wenn der randpunkt 5 pixel entfernt ist aber die kugel 6 pixel neu gezeichnet wird. das die dann durch gehen würde. müsste man dann aber halt mit ner logik abfragen. ob es sein kann das der flieger getroffen wird. oder halt alle pixelpunkte des fliegers abfragen. wenn der flieger z.b. 20*20 pixel eine kugel nur 5 pixel und sich diese 5 pixel bewegt muss sie ja treffen und kann gar net durchgehen.

    das mit dynamisch meine ich.

    ich definiere einen festen punkt des fliegers. z.b. den mittelpunkt oder den randpunkt der pixelspitze.

    der liegt im gesamten bildbereich bei z.b. ( 800 * 600 ) bei x = 450 / y = 500
    also P(450/500) in diese richtung wird dann geschossen. die kugel bewegt sich dann in dieser linie auf diesen pixel zu. geht aber slebstverstänldich weiter falls nie was getroffen wird. auf den weg dorhin wird natürlich auch abgefragt ob flieger bereits getroffen.

    wenn der flieger getroffen

    wird das objekt kugel nicht mehr neu gezeichnet und wird gelöscht

    so hab ich das ungefähr gemeint

    ist dies nicht gut oder mit der kollisionsabfrage? wie mach man dies dann normalerweise?

    Ja ich muss mich echt noch mit der grafik API befassen. das ist richtig. aber irgendwann muss ich ja anfangen.

    Hab einen freund der kann gut musik und grafik machen. ich befasse mich nur mit dem programmieren.

    die mainschleife wäre dann bei mir

    dass der level 1 solange läuft bis das letze bild vollständig gezeichnet ist.

    natürlich hab ich mir gedacht ich mach z.b. 3 bilder die in einer schleife laufen bis der haupgegner tot ist. weil man weiss ja nie wie lange man braucht. und wenn dieser tot ist. wird noch was angezeigt und dann next level geladen

    EDIT: ja jede kugel ist ein grafik objekt. die grafik brauch ich halt einmal. und jede kugel wird für sich berechnet und neu gezeichnet.
    geht das? kann ich dann z.b. 80 kugel + flieger + feinde berechnen ohne probs.
    + musik + soundeffekte?

    Hab mir halt gedacht ich mach erst das scroolen, dann den flieger hinzeichnen. dann definieren wie er sich im raum max beswegen kann, so dass er nicht aus dem rand kann und beim rand stehenbleibt und nicht weiter z.b. links bewegt werden kann.

    dann eigene kugeln machen. alles testen dann mal ein feind kordinieren. ect.

    0
  • M

    also, ich denke, die 80 kugeln malen, den flieger und die gegner dürfte eigentlich kein problem darstellen, wenn man es gescheit anstellt. Mit SDL kenn ich mich leider nicht aus, wie das da ist, aber mit DX geht es auf jeden Fall und ich wette, das gaht mit SDL auch...
    Andere Spiele schaffen das ja auch, und mit den heutigen rechnern sowieso.
    Und ich denke, sone komplizierte KI werden die Gegner auch nciht haben, dass die berechnung da so lange dauert...

    Das mit einem globalen Kugelmanager, das gefällt mir persönlich eigenltihc ganz gut, einfach sowas wie g_KugelMan->AddKugel(...) oder so, dann noch Render/Move Fkt für den Manager und dann vielleicht noch: PointHitsBowl oder so ähnlich...

    Wär nciht schlecht, glaub ich

    0
  • F

    naja keine ahnung ich dachte halt ich mach ein vector von kugeln die dann abgearbeitet werden bis entweder alle oder halt wenn eine schon trifft dann eine abbruchbedingung.

    könne z.b. so aussehen

    struct KUGELN
{

   ... act_pos;
   int geschwindigkeit;
   ... richtung;
   int schaden;
   ect.

}

KUGELN Zu_zeichnende_Kugeln_gelbe_vec;

// Wenn gegner schiesst eine gelbe schwache dann
// Fkt. aufrufen die dann ein neue kugel in den vector dranhängt mit den werten

Kugel_neu_aufnehmen_gelbe();

// Wenn Kugeln gezeichnet werden muessen
// Die Funk. aufrufen
Kugeln_zeichnen_berechnen();

// In der funktion halt dann dass bild neu berechnen ob getroffen schaden ect.

    Es ist gerade nach 2am also ist es maybe gerade nicht ganz so durchdacht. Und halt von den momentanen bezeichnungen. 😉

    Ich halte euch auf dem laufenden.

    Natürlich kann man auch eine Klasse machen. Dann verschiedene Kugeln ableiten
    gelbe = schwache, blaue = dynamische, grosse gelbe = starke

    und dann die methoden

    Add_Kugel()
Remove_Kugel()
Zeichne_Kugel()
Berechne_Schaden()
//.....
    0

  • KUGELN Zu_zeichnende_Kugeln_gelbe_vec;

    Ernsthafte Antwort: das ist Schrott. Willst du dann für jede neue Kugelart 'nen neuen Vektor proggrammieren?

    Speichere den Typ in der struct.

    Bye, TGGC (Der Held ist zurück)

    0
  • F

    ne kein neuer vector! sondern eher mit pushback() dranhaengen und ein eintrag besteht dann aus der struct KUGELN
    und wenn man die funktion aufruft, dass man die kugeln zeichnen muss, geht halt ein pointer "durch" den vector und ueberpruft ob getroffen und dann wenn nicht wird er in der neuen position gezeichnet und wenn ja dann dies und dass.

    ist die idea nicht so doll? eigentlich brauch ich da ja keine extra klasse oder?

    0
  • S

    Wäre es nicht viel schöner eine Basisklasse "Kugel" zu erstellen, und einen
    Vector dieser Klassen zu erstellen (std::vector<Kugel *>), nun leitet man für
    jede der verschiedenen Kugeln eine Klasse ab in welcher, dann die für diesen Typ
    richtigen Aktionen definiert sind.
    Fände ich so um welten schöner, man müsste nur eine Funktion Kugeln_move () aufrufen
    welche den Vektor durchläuft und für jedes Objekt eine Funktion aufruft, welche
    wiederum das Bewegen sowie das Zeichnen übernimmt und evt. Kollisionen überprüft,...

    0
  • M

    ich würde eine struct Kugel nehmen, mit member Typ und richtung usw.

    Und eine große Klasse, namesn Kugelmanager, mit Methoden wie AddKugel() oder MoveAll() RenderAll() usw.
    Die Klasse kann das dann alles schön intern handlen und der nutzer braucht nur die paar Methoden, und dalles müsste wunderbar klappen

    0
  • F

    naja nachdem ich mit SDL beschäftigt habe und ich sagen muss dass es nicht ganz easy ist

    hab ich mir schweren herzen dazu entschieden ( und da es mein Kumpel auch macht, kann man projekte zusammen proggen )

    blitzbasic zu nehmen.

    da habe ich es innerhalb eines nachmittags geschafft

    leveinen el zu scrollen
    flieger auf dem bildschirm mit joypad zu bewegen
    und ihn x schuesse abfeuern zu lassen bis diese den bildbereich verlassen

    echt alles easy. muss jetzt halt noch gegner machen ect.

    aber innerhalb eines nachmittags ( 3 std ) ist dies eine menge wenn man bei null anfangen muss

    ich muss aber auch sagen das

    blitzbasic ( BB ) echt einfach ist aber im gegensatz zu C++ natürlich eine "komische" sprache. Da ist nicht alles genau definiert und es wird gepfuscht.
    statt struct gibt es da TYPE was anfangs komisch zu bedienen ist aber wenn man es verstanden hat gehts. besonders da ein TYPE auch zugleich ein arrayist !!! mit dem type TYPE ist. irgendwie ist alles anders. und keine OO aber egal wenigstens gibts da Func die man auslagern kann und man nicht auf GoSub angewiesen ist.

    Also für alle die keinen grossen stress haben wollen und schnell was einfach-schwieriges proggen wollen kann ich Blitzbasic nur empfehlen.

    SDL hätt ich ja gern gemacht. aber keine gescheite info. die tutorials sind echt selten und rar und kurz. vieles wird gar nicht angesprochen. und ständig muss man gucken wo man was erhält zum includen wie z.b. SDL_IMAGE oder so.

    also d.h. leider kann ich wenn ich ein game prob hab mich nicht mehr an euch wenden 😞
    was ich wahrscheinlich dank des dummy BB auch nicht muss.

    aber ich verspreche euch dass ich in zukunft wenn ich mehr zeit mal habe mein game mit DIRECTX umsetzen werde.

    0

  • Juhu, den sind wir los!

    Bye, TGGC (Der Held ist zurück)

    0
Anmelden zum Antworten