[C#] Kleines Spielchen programmiert

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • [C#] Kleines Spielchen programmiert

    Wie findet ihr das Spiel? 24
    1.  
      Für das erste Spiel nicht schlecht! (10) 42%
    2.  
      Toll gemacht! (5) 21%
    3.  
      Nicht wirklich gut (3) 13%
    4.  
      Schlecht (Mit Begründung) (3) 13%
    5.  
      Naja, geht so (2) 8%
    6.  
      Sehr gut (1) 4%
    Anzeige
    Hallo, dieser Unterbereich nennt sich ja Coding & Design, und da ich noch nichts gefunden hab (ok hab auch nicht gesucht aber wayne xD), was mit CODING zu tun hat, dachte ich, ich mach mal nen Thread...
    über ein Spiel in der Sprache C#, welches ich in den letzten Tagen programmiert hab.
    Ist ein bisschen ähnlich wie Pokemon, besteht aber nur aus Text... Habs nämlich in der Konsole programmiert^^

    Hier ist der Link zum Video auf Youtube (hoffe das ist erlaubt?!)
    youtube.com/watch?v=aicP9rVxuXA


    Wie findet ihr das Spiel? Ich weiss, es ist nichts unglaubliches, aber bedenkt: Ich bin 13 und lerne die Sprache noch nicht wirklich lange, und ausserdem ist das mein erstes Spiel :)

    Also: Freu mich auf Kommentare! :thumbup:
  • Für das erste Spiel auf jeden Fall gut.
    Gut gemacht das du an Zufallsgeneratoren gedacht hast. klar, es ist bisher nur eine kleine "Kampfsimulation" und bietet nicht viel. Aber es ist auch toll das zumindest die Werte sich pro Runde ändern und der Gegner entsprechend seines Lebens per Zufall die Heilfertigkeit benutzt.

    Ausbau Möglichkeiten wären nun zum Beispiel:

    • ein Multiplayer (also ein PvP, an einem PC natürlich)
    • eine Auswahl an Kampfgefährten mit verschiedenen Fertigkeiten
    • Aufbau eines Teams / Auswahl eines Teams
    • ein [lexicon]GUI[/lexicon]
    • Ausgeglichenes Kampfsystem



    So ein "einfaches" Spiel zu Programmieren ist eigentlich die beste Möglichkeit das Programmieren zu lernen (Wenn Grundkenntnisse vorhanden und man lernen soll diese anzuwenden).
    Um Java in der Schule zu lernen sollten wir ein Zahlen rate Spiel Programmieren und immer weiter erweitern. Auf diesen weg habe ich es am besten gelernt
  • Dschungelflamme schrieb:


    Hallo, danke euch beiden für die netten Kommentare ;)

    St3v3 schrieb:


    • ein Multiplayer (also ein PvP, an einem PC natürlich)
    • eine Auswahl an Kampfgefährten mit verschiedenen Fertigkeiten
    • Aufbau eines Teams / Auswahl eines Teams
    • ein [lexicon]GUI[/lexicon]
    • Ausgeglichenes Kampfsystem

    1. Multiplayer geht (soweit ich gerade weiss) nicht mit der Konsolenanwendung, oder höchstens beschränkt, allerdings hab ich schon darüber nachgedacht, zu weit einfach an einem Computer zu spielen^^ Also so, dass der Zufallsgenerator deaktiviert wird und das Programm anstelle dessen auf eine weitere Benutzereingabe wartet.
    2. Inwiefern Kampfgefährten? So dass man bei einer bestimmten Runde n 'Tier' aussuchen kann, welches dann den Schaden oder Heilrate erhöht? Wie stellst du dir das etwa vor? :)
    3. Wird zwar komplex aber werd ich definitiv irgendwann versuchen!
    4. Muss mir den Thread noch anschauen ~
    5. Vorschläge? :)

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Dschungelflamme ()

  • Anzeige

    Dschungelflamme schrieb:

    1. Multiplayer geht (soweit ich gerade weiss) nicht mit der Konsolenanwendung, oder höchstens beschränkt, allerdings hab ich schon darüber nachgedacht, zu weit einfach an einem Computer zu spielen^^ Also so, dass der Zufallsgenerator deaktiviert wird und das Programm anstelle dessen auf eine weitere Benutzereingabe wartet.
    2. Inwiefern Kampfgefährten? So dass man bei einer bestimmten Runde n 'Tier' aussuchen kann, welches dann den Schaden oder Heilrate erhöht? Wie stellst du dir das etwa vor?
    3. Wird zwar komplex aber werd ich definitiv irgendwann versuchen!
    4. Muss mir den Thread noch anschauen ~
    5. Vorschläge?
    1. So war es gemeint. Du kannst beide Optionen (singleplayer, Multiplayer) in einem Menü zur Auswahl anbieten
    2. Ich dachte da eher daran das Verschiedene "Wesen" gewählt werden können mit denen man Kämpft (sowas wie Pokemon ;) )
    3. Damit meinte ich das man ein Team aus Wesen (Monstern) zusammen stellen kann, so wie man es zb aus Pokemon kennt
    4. GUI = Graphical User Interface (zu dt. : Grafische Benutzeroberfläche) ist einfach nur eine Grafische Oberfläche für das Spiel
    5. Wenn Verschiedene "Monster" eingebaut werden so können vorteile eingebaut werden, verschiedene Werte pro Monster, Wasser Monster haben vorteile gegenüber Feuer Wesen,... kann man beliebig erweitern :D

    Aber alles zu seiner Zeit. Ist ja deine Entscheidung was du daraus machst ;)
  • Jeder fängt mal klein an, von daher finde ich das schon recht gut gemacht. Von der Idee zur Umsetzung ist immer ein langer Prozess. ^^

    Dein Programm musste jetzt nur noch von deiner Command Umgebung befreihen und als Windows Fenster gestalten. Erst dann hat man die Möglichkeiten Grafiken einzubauen.

    Weil du musst auch dran denken das heutige Windows Systeme keine grafische DOS Anzeigemodi mehr haben für die Command Konsole. Ich glaube das letzte Windowssystem das das noch konnte war XP gewesen.

    Also wie gesagt die Umgebung der Anwendung wechseln von CLI auf GUI. Und dann... könnte man auch später sich um die Grafik kümmern.

    Mein erstes Spiel war auch recht simple. Aber hatte schon Grafik drin ^^ So ein Boulder Dash Clone ^^ + Editor sogar mit eingebaut sodass man seine Level selbst erweitern konnte. Als Puzzle Spiel ist das bei uns in der Schule damals gut angekommen, da es auf den Schulrechnern lief wo sonst gar keine Spiele erlaubt waren, haben wir dort halt ein programmiert. ^^

    In dem Sinne: Unschuldig gewesen XD Wir haben ja nur die Dinge verwendet die auf dem Rechner waren xD

    Naja, Back to Topic: Die KI vllt etwas vereinern. Ein Gegner der per Zufall nur dumme Sachen macht, ist ja kein Gegner ^^ Beispiel wäre hierfür das wenn der Gegner auf soviel % seiner Lebenspunkte runter ist, er sein komplettes Angriffsverhältnis ändert. Auch wenn er sich heilen sollte, müsste er von dem Zufallprinzip her nur noch Attacken nehmen die dem Spieler zusetzen.
    Bedeutet:

    Bei 100% (Kampf beginnt): Der Gegner versucht den Spieler durch auswahl seiner Kampfmöglichkeiten den schwächsten Angiff zu 85 % einzusetzen, wärend die anderen Optionen von ihm die restlichen 15 % bilden
    Hat der Gegner zum ersten mal seine Lebenpunkte unter 70% nutzt er nur noch zu 50 % den schwächsten Angriff, zu 25 % versucht er sich zu heilen (als Beispiel) und zu 25 % nutzt er den stärksten Angriff.
    Unter 50 % seiner Lebenenergie nutzt er regelrecht nur noch den stärksten Angriff und zu 35 % Lebensenergie wiederherstellen (falls möglich vom Gegner)

    Dieses System lässt den Spieler glauben das der Gegner sich intelligent verhällt und sich anzupassen versucht. Was aber eigentlich ein recht einfaches Mittel ist um Gegner stärker werden zu lassen ^^

    EDIT:
    Wenn es keine Windows GUI geben wird, vllt wäre eine Kreative Konsolengrafik schon ok ^^
    Gibs ja ne Menge wie man sowas machen kann. Beispiele: Bild1, Bild2

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Sagaras ()

  • Kleine Spielchen eignen sich doch immer super zum Programmieren lernen ;)
    Würde dir auch vorschlagen, das ganze weiterzuentwickeln, wie St3v3 es vorgeschlagen hat. Allerdings zwei Anmerkungen:

    1. Multiplayer geht (soweit ich gerade weiss) nicht mit der Konsolenanwendung, oder höchstens beschränkt, allerdings hab ich schon darüber nachgedacht, zu weit einfach an einem Computer zu spielen^^ Also so, dass der Zufallsgenerator deaktiviert wird und das Programm anstelle dessen auf eine weitere Benutzereingabe wartet.

    Auch in ner Konsolenanwendung müsstest du Netzwerkfunktionalität haben, wenn .NET nicht vollkommen bescheuert ist. Aber von Netzwerk würde ich an deiner Stelle erst einmal die Finger lassen, wenn du den Protokollstack etc. noch nicht einigermaßen verstehst - auf dem Gebiet kann man einfach viel falsch machen.

    4. GUI = Graphical User Interface (zu dt. : Grafische Benutzeroberfläche) ist einfach nur eine Grafische Oberfläche für das Spiel

    Aber in der Regel fürchterlich nervig zu programmieren und in der Regel der Punkt, an dem ich persönlich die Lust verliere. Würde ich irgendwo sehr weit hinten in der Prioritätenliste einordnen.

    Edit:
    Oder meinst du eine GUI in der Konsole? Eher nicht, oder? xD

    Eine interaktivere Steuerung in der Konsole wäre aber auch möglich. Sodass man dort GUI-Elemente quasi nachstellt und Navigation mit Tab und den Pfeiltasten erlaubt (natürlich mit ner intelligenten Belegung für Kurzbefehle) oder sowas. Das dann kombiniert mit ner entsprechenden Grafik (siehe Sagaras) und das Ding ist schon deutlich aufpoliert ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von VikingGe ()

  • Gar nicht mal schlecht... ich finde nur, dass du dich als nächstes mal mit Objekten beschäftigen solltest. Ist auf jeden Fall sinnvoller als ein GUI, denn wie VikingGe schon sagte: GUI programmieren ist lästig...
    Aber sonst: Guter Anfang. Ich würd zu gern mal den Code sehen...
    Grüße, GLaDOS

    "Do you know who I am? I'm the man whose gonna burn your house down - with the lemons! I'm gonna get my engineers to invent a combustible lemon that'll burn your house down!" - Cave Johnson, CEO of Aperture Science

    YouTube: Max Play

    Rechtschreibung und Grammatik sind eine Tugend, aber jeder macht mal Fehler...
  • Freut mich, dass es einigen gefällt ;)

    Also, hier ist der Code (jaa ich weiss man hätte es um einiges besser machen können und jaa, ich weiss, ich hab VIEL zu viel Variablen verwendet, aber es funktioniert xD)
    Spoiler anzeigen


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Threading;

    namespace Kampfspiel
    {
    class Program
    {
    static void Main(string[] args)
    {
    int PlayersTurn = 1;
    int EnemysTurn = 0;
    int PlayerAttack = 0;
    int EnemyAttack = 0;
    int PlayerUltimativerSchlag = 1;
    int EnemyUltimativerSchlag = 1;
    Random Rndm = new Random();
    bool PlayGame = true;
    string Verfügbar = "";
    int Remaining = 0;
    int PlayerAttackWith1 = 0;
    int PlayerAttackWith2 = 0;
    int PlayerAttackWith3 = 0;
    int EnemyAttackWith1 = 0;
    int EnemyAttackWith2 = 0;
    int EnemyAttackWith3 = 0;
    int Addition = 0;
    int EAddition = 0;
    int Verteidigung = 0;
    int EVerteidigung = 0;
    Random Trefferrate = new Random();
    Random Volltreffer = new Random();
    Random ETrefferrate = new Random();
    Random EVolltreffer = new Random();
    int Runde = 8; //
    bool IncreaseHP = true;
    int MaxPlayerHP = 200;
    int MaxEnemyHP = 200;
    int PlayerHP = 0;
    int EnemyHP = 0;
    Random RndmAddition0 = new Random();
    Random RndmEAddition0 = new Random();
    Random RndmVerteidigung0 = new Random();
    Random RndmEVerteidigung0 = new Random();
    int RndmAddition1 = 0;
    int RndmEAddition1 = 0;
    int RndmVerteidigung1 = 0;
    int RndmEVerteidigung1 = 0;
    bool IsSdSAvailable = true; //
    int PlayerSdS = 2;
    int EnemySdS = 2;
    string HMPlayerSdS = "";
    int AvailableAttacks = 3;
    Random RndmESdS = new Random();
    bool IsTVAvailable = true; //
    int PlayerTV = 1;
    int EnemyTV = 1;
    string HMPlayerTV = "";
    int Zug = 0;
    int EZug = 0;
    int Beenden = 0;
    int EBeenden = 0;

    while (PlayGame == true)
    {
    while (IncreaseHP == true)
    {
    IncreaseHP = false;
    PlayerHP = MaxPlayerHP;
    EnemyHP = MaxEnemyHP;
    }

    while (PlayerHP > 0 && EnemyHP > 0 && PlayersTurn == 1)
    {
    PlayerAttack = 0;
    PlayersTurn = 0;
    int EndTrefferrate = Trefferrate.Next(1, 101);
    int EndVolltreffer = Volltreffer.Next(1, 101);
    RndmEAddition1 = RndmEAddition0.Next(1, 21);

    if (PlayerUltimativerSchlag > 0)
    Verfügbar = "Noch 1 Mal verfügbar!";
    else
    Verfügbar = "Nicht mehr verfügbar!";

    if (PlayerSdS == 2)
    HMPlayerSdS = "Noch 2 Mal verfügbar!";
    if (PlayerSdS == 1)
    HMPlayerSdS = "Noch 1 Mal verfügbar!";
    if (PlayerSdS == 0)
    HMPlayerSdS = "Nicht mehr verfügbar!";

    if (PlayerTV > 0)
    HMPlayerTV = "Noch 1 Mal verfügbar!";
    else
    HMPlayerTV = "Nicht mehr verfügbar!";

    Console.WriteLine("Welchen Angriff möchtest du ausführen? Aktuelle Lebenspunkte:");
    Console.WriteLine(" Spieler: " + PlayerHP + "/" + MaxPlayerHP);
    Console.WriteLine("Dmg TR Crit Angriffsname Taste Gegner: " + EnemyHP + "/" + MaxEnemyHP);
    Console.WriteLine(" Runde: " + Runde);
    Console.WriteLine("10 95 9 Schlag 1");
    Console.WriteLine("20 70 6 Krallenhieb 2");
    Console.WriteLine("50 45 3 Ultimativer Schlag 3 (" + Verfügbar + ")");

    if (IsSdSAvailable)
    {
    Console.WriteLine("+ 100 - Segen der Sterne 4 (" + HMPlayerSdS + ")");
    AvailableAttacks = 4;
    }
    if (IsTVAvailable)
    {
    Console.WriteLine("~ 80 - Tödliche Verbrennung 5 (" + HMPlayerTV + ")");
    AvailableAttacks = 5;
    }

    try
    {
    PlayerAttack = int.Parse(Console.ReadLine());
    }
    catch (Exception)
    {
    Console.WriteLine("Ein Fehler ist aufgetreten. Bitte gib eine Zahl ein!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayersTurn = 1;
    break;
    }

    if (PlayerAttack > AvailableAttacks || PlayerAttack < 1)
    {
    Console.WriteLine("Ein Fehler ist aufgetreten. Bitte gib nur gültige Zahlen ein!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayersTurn = 1;
    break;
    }

    if (PlayerAttack == 3 && PlayerUltimativerSchlag == 0)
    {
    Console.WriteLine("Du kannst den Ultimativen Schlag nur einmal pro Runde einsetzen!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayersTurn = 1;
    break;
    }

    if (PlayerAttack == 4 && PlayerSdS == 0)
    {
    Console.WriteLine("Du kannst den Segen der Sterne nur Zwei Mal pro Runde benutzen!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayersTurn = 1;
    break;
    }

    if (PlayerAttack == 5 && PlayerTV == 0)
    {
    Console.WriteLine("Du kannst die Tödliche Verbrennung nur einmal pro Runde einsetzen!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayersTurn = 1;
    break;
    }


    if (PlayerAttack == 1)
    {
    Console.WriteLine("Du setzt 'Schlag' ein!");
    Thread.Sleep(1000);
    if (EndTrefferrate < 96)
    {
    if (EndVolltreffer < 10)
    {
    PlayerAttackWith1 = Damage(20, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith1;
    Console.WriteLine("Volltreffer! Dein Gegner hat ganze " + PlayerAttackWith1 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    else
    {
    PlayerAttackWith1 = Damage(10, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith1;
    Console.WriteLine("Getroffen! Dein Gegner hat " + PlayerAttackWith1 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }
    else
    {
    Console.WriteLine("Verfehlt!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }
    else if (PlayerAttack == 2)
    {
    Console.WriteLine("Du setzt 'Krallenhieb' ein!");
    Thread.Sleep(1000);
    if (EndTrefferrate < 71)
    {
    if (EndVolltreffer < 7)
    {
    PlayerAttackWith2 = Damage(40, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith2;
    Console.WriteLine("Volltreffer! Dein Gegner hat ganze " + PlayerAttackWith2 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    else
    {
    PlayerAttackWith2 = Damage(20, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith2;
    Console.WriteLine("Getroffen! Dein Gegner hat " + PlayerAttackWith2 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }
    else
    {
    Console.WriteLine("Verfehlt!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }
    else if (PlayerAttack == 3 && PlayerUltimativerSchlag == 1)
    {
    Console.WriteLine("Du setzt 'Ultimativer Schlag' ein!");
    Thread.Sleep(1000);
    if (EndTrefferrate < 46)
    {
    if (EndVolltreffer < 4)
    {
    PlayerAttackWith3 = Damage(90, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith3;
    Console.WriteLine("Volltreffer! Dein Gegner hat ganze " + PlayerAttackWith3 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayerUltimativerSchlag = 0;
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    else
    {
    PlayerAttackWith3 = Damage(50, Addition, EVerteidigung);
    EnemyHP = EnemyHP - PlayerAttackWith3;
    Console.WriteLine("Getroffen! Dein Gegner hat " + PlayerAttackWith3 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayerUltimativerSchlag = 0;
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }
    else
    {
    Console.WriteLine("Verfehlt!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayerUltimativerSchlag = 0;
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }

    else if (PlayerAttack == 4 && PlayerSdS > 0 && IsSdSAvailable)
    {
    PlayerSdS--;
    Console.WriteLine("Du setzt 'Segen der Sterne' ein!");
    Thread.Sleep(1000);
    int PlayerAttackWith4 = SdS(PlayerHP, MaxPlayerHP);
    PlayerHP = PlayerHP + PlayerAttackWith4;
    Console.WriteLine("Getroffen! Deine Lebenspunkte wurden aufgefüllt!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }

    else if (PlayerAttack == 5 && PlayerTV > 0 && IsTVAvailable)
    {
    if (EndTrefferrate < 81)
    {
    PlayerTV--;
    Console.WriteLine("Du setzt 'Tödliche Verbrennung' ein!");
    Zug = 1;
    Thread.Sleep(2000);
    Console.Clear();
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    else
    {
    Console.WriteLine("Verfehlt!");
    Thread.Sleep(2000);
    Console.Clear();
    PlayerTV--;
    RndmAddition1 = RndmAddition0.Next(1, 21);
    }
    }

    int PlayerAttackWith5 = 0;

    if (Zug == 3)
    {
    PlayerAttackWith5 = TV(3);
    Beenden = 1;
    }
    if (Zug == 2)
    {
    PlayerAttackWith5 = TV(2);
    Zug++;
    }
    if (Zug == 1)
    {
    PlayerAttackWith5 = TV(1);
    Zug++;
    }

    if (Zug > 0 && Zug < 4)
    {
    Console.WriteLine("Dein Gegner hat " + PlayerAttackWith5 + " Schaden über Zeit erhalten!");
    EnemyHP = EnemyHP - PlayerAttackWith5;
    Thread.Sleep(2000);
    Console.Clear();
    }

    if (Beenden == 1)
    {
    Zug = 0;
    Beenden = 0;
    }
    EnemysTurn = 1;
    }

    while (PlayerHP > 0 && EnemyHP > 0 && EnemysTurn == 1)
    {
    EnemyAttack = 0;
    Console.Clear();
    Console.WriteLine("Warten auf den Zug des Gegners...");
    RndmEVerteidigung1 = RndmEVerteidigung0.Next(1, 11);
    Thread.Sleep(1000);
    if (Runde > 5)
    EnemyAttack = Rndm.Next(1, 6);
    else if (Runde > 3)
    EnemyAttack = Rndm.Next(1, 5);
    else
    EnemyAttack = Rndm.Next(1, 4);

    int EndETrefferrate = ETrefferrate.Next(1, 101);
    int EndEVolltreffer = EVolltreffer.Next(1, 101);
    EnemysTurn = 0;
    double Hälfte = MaxEnemyHP / 2;


    if (EnemyHP < Hälfte && IsSdSAvailable && EnemySdS > 0)
    EnemyAttack = 4;

    if (EnemyAttack == 3 && EnemyUltimativerSchlag == 0)
    {
    EnemysTurn = 1;
    break;
    }
    if (EnemyAttack == 4 && EnemySdS == 0)
    {
    EnemysTurn = 1;
    break;
    }
    if (EnemyAttack == 5 && EnemyTV == 0)
    {
    EnemysTurn = 1;
    break;
    }

    if (EnemyAttack == 1)
    {
    Console.WriteLine("Dein Gegner setzt 'Schlag' ein!");
    Thread.Sleep(1000);
    if (EndETrefferrate < 96)
    {
    if (EndEVolltreffer < 10)
    {
    EnemyAttackWith1 = Damage(20, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith1;
    Console.WriteLine("Volltreffer! Du hast ganze " + EnemyAttackWith1 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    else
    {
    EnemyAttackWith1 = Damage(10, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith1;
    Console.WriteLine("Getroffen! Du hast " + EnemyAttackWith1 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }
    else
    {
    Console.WriteLine("Dein Gegner hat dich nicht getroffen!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }
    else if (EnemyAttack == 2)
    {
    Console.WriteLine("Dein Gegner setzt 'Krallenhieb' ein!");
    Thread.Sleep(1000);
    if (EndETrefferrate < 71)
    {
    if (EndEVolltreffer < 7)
    {
    EnemyAttackWith2 = Damage(40, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith2;
    Console.WriteLine("Volltreffer! Du hast ganze " + EnemyAttackWith2 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    else
    {
    EnemyAttackWith2 = Damage(20, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith2;
    Console.WriteLine("Getroffen! Du hast " + EnemyAttackWith2 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }
    else
    {
    Console.WriteLine("Dein Gegner hat dich nicht getroffen!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }
    else if (EnemyAttack == 3 && EnemyUltimativerSchlag == 1)
    {
    Console.WriteLine("Dein Gegner setzt 'Ultimativer Schlag' ein!");
    Thread.Sleep(1000);
    if (EndETrefferrate < 46)
    {
    if (EndEVolltreffer < 4)
    {
    EnemyAttackWith3 = Damage(90, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith3;
    Console.WriteLine("Volltreffer! Du hast ganze " + EnemyAttackWith3 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    EnemyUltimativerSchlag = 0;
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    else
    {
    EnemyAttackWith3 = Damage(50, EAddition, Verteidigung);
    PlayerHP = PlayerHP - EnemyAttackWith3;
    Console.WriteLine("Getroffen! Du hast " + PlayerAttackWith3 + " Lebenspunkte verloren!");
    Thread.Sleep(2000);
    EnemyUltimativerSchlag = 0;
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }
    else
    {
    Console.WriteLine("Dein Gegner hat dich nicht getroffen!");
    Thread.Sleep(2000);
    EnemyUltimativerSchlag = 0;
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }

    else if (EnemyAttack == 4 && EnemySdS > 0 && IsSdSAvailable)
    {
    double Drittel = MaxEnemyHP / 1.5;
    int DoSdS = 0;

    if (EnemyHP < Hälfte)
    {
    DoSdS = 100;
    }
    else if (EnemyHP < Drittel)
    {
    DoSdS = RndmESdS.Next(1, 101);
    }

    if (DoSdS > 50)
    {
    EnemySdS--;
    Console.WriteLine("Dein Gegner setzt 'Segen der Sterne' ein!");
    Thread.Sleep(1000);
    int EnemyAttackWith4 = SdS(EnemyHP, MaxEnemyHP);
    EnemyHP = EnemyHP + EnemyAttackWith4;
    Console.WriteLine("Getroffen! Die Lebenspunkte deines Gegners wurden aufgefüllt!");
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    else
    {
    EnemysTurn = 1;
    break;
    }
    }

    else if (EnemyAttack == 5 && EnemyTV > 0 && IsTVAvailable)
    {
    Console.WriteLine("Dein Gegner setzt 'Tödliche Verbrennung' ein!");
    if (EndETrefferrate < 81)
    {
    EnemyTV--;
    EZug = 1;
    Thread.Sleep(2000);
    Console.Clear();
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    else
    {
    Thread.Sleep(2000);
    Console.WriteLine("Dein Gegner hat dich nicht getroffen!");
    Console.Clear();
    EnemyTV--;
    RndmVerteidigung1 = RndmVerteidigung0.Next(1, 11);
    }
    }

    int EnemyAttackWith5 = 0;

    if (EZug == 3)
    {
    EnemyAttackWith5 = ETV(3);
    EBeenden = 1;
    }
    if (EZug == 2)
    {
    EnemyAttackWith5 = ETV(2);
    EZug++;
    }
    if (EZug == 1)
    {
    EnemyAttackWith5 = ETV(1);
    EZug++;
    }

    if (EZug > 0 && EZug < 4)
    {
    Console.WriteLine("Du hast " + EnemyAttackWith5 + " Schaden über Zeit erhalten!");
    PlayerHP = PlayerHP - EnemyAttackWith5;
    Thread.Sleep(2000);
    Console.Clear();
    }

    if (EBeenden == 1)
    {
    EZug = 0;
    EBeenden = 0;
    }

    PlayersTurn = 1;

    }

    if (EnemyHP <= 0)
    {
    Remaining = PlayerHP - EnemyHP;
    Addition = Addition + RndmAddition1;
    EAddition = EAddition + RndmEAddition1;
    Verteidigung = Verteidigung + RndmVerteidigung1;
    EVerteidigung = EVerteidigung + RndmEVerteidigung1;
    MaxPlayerHP = MaxPlayerHP + 20;
    MaxEnemyHP = MaxEnemyHP + 20;
    PlayerUltimativerSchlag = 1;
    EnemyUltimativerSchlag = 1;
    int FinalDamage = Addition - EVerteidigung;
    int FinalEDamage = EAddition - Verteidigung;
    PlayerSdS = 2;
    EnemySdS = 2;
    PlayerTV = 1;
    EnemyTV = 1;

    if (Runde > 2)
    {
    IsSdSAvailable = true;
    }
    if (Runde > 4)
    {
    IsTVAvailable = true;
    }

    IncreaseHP = true;
    Console.WriteLine(" !CONGRATULATIONS!");
    Console.WriteLine();
    Console.WriteLine(" Du hast Runde " + Runde + " überstanden! Gut gemacht!");
    Console.WriteLine();
    Console.WriteLine("Statistik:");
    Console.WriteLine();
    Console.WriteLine("Deine Leben am Ende der Runde: " + PlayerHP);
    Console.WriteLine("Die Leben deines Gegners am Ende der Runde: " + EnemyHP);
    Console.WriteLine("Du hattest also noch " + Remaining + " Leben mehr als dein Gegner");
    Console.ReadLine();
    Console.Clear();
    Console.WriteLine("In der nächsten Runde werden die Werte von dir und deinem Gegner wie folgt verändert (verglichen mit Runde " + Runde + ") :");
    Console.WriteLine();
    Console.WriteLine("Deine Lebenspunkte: +20");
    Console.WriteLine("Gegnerische Lebenspunkte: +20");
    Console.WriteLine();
    Console.WriteLine("Dein Angriff: +" + RndmAddition1 + " (verglichen mit Runde 1: +" + Addition + ")");
    Console.WriteLine("Gegnerischer Angriff: +" + RndmEAddition1 + " (verglichen mit Runde 1: +" + EAddition + ")");
    Console.WriteLine();
    Console.WriteLine("Deine Verteidigung: +" + RndmVerteidigung1 + " (verglichen mit Runde 1: +" + Verteidigung + ")");
    Console.WriteLine("Gegnerische Verteidigung: +" + RndmEVerteidigung1 + " (verglichen mit Runde 1: +" + EVerteidigung + ")");
    Console.WriteLine();
    Console.WriteLine("Du machst deinem Gegner in der Nächsten Runde also " + FinalDamage + " (+ Angriffsschaden) Damage");
    Console.WriteLine("Dein Gegner macht dir in der Nächsten Runde also " + FinalEDamage + " (+ Angriffsschaden) Damage");
    Console.ReadLine();
    Console.Clear();
    Runde++;
    PlayersTurn = 1;
    }

    if (PlayerHP <= 0)
    {
    Remaining = EnemyHP - PlayerHP;
    PlayGame = false;
    Console.Clear();
    Console.WriteLine(" PECH GEHABT...");
    Console.WriteLine();
    Console.WriteLine(" Du wurdest in Runde " + Runde + " besiegt! Nächstes Mal klappts bestimmt...!");
    Console.WriteLine();
    Console.WriteLine("Statistik:");
    Console.WriteLine();
    Console.WriteLine("Deine Leben am Ende der Runde: " + PlayerHP);
    Console.WriteLine("Die Leben deines Gegners am Ende der Runde: " + EnemyHP);
    Console.WriteLine("Du hattest also " + Remaining + " Leben weniger als dein Gegner");
    Console.ReadLine();
    Console.Clear();
    Console.WriteLine(" GAME OVER");
    Console.WriteLine(" Vielen Dank für das Spielen dieses Spiels!");
    Console.WriteLine(" Copyright by Sven Zanetti, 2014");
    }



    }

    Console.ReadLine();
    }

    static int Damage(int AttackDamage, int EigenerLvlUpAngriff, int GegnerischeVerteidigung)
    {
    int y = AttackDamage + EigenerLvlUpAngriff;
    int TotalDamage = y - GegnerischeVerteidigung;

    if (TotalDamage < 1)
    {
    Console.WriteLine("Da die Verteidigung des Abwehrenden höher ist als als Angriff des Angreifenden, macht der Angriff standardmässig 10 Damage.");
    Thread.Sleep(3000);
    return 10;
    }
    else
    return TotalDamage;
    }

    static int SdS(int CurrentLife, int MaxLife)
    {
    int x = MaxLife - CurrentLife;

    if (x > 50)
    return 50;
    else
    return x;
    }

    static int TV(int Zug)
    {
    if (Zug == 1)
    return 15;
    else if (Zug == 2)
    return 35;
    else if (Zug == 3)
    return 70;
    else
    return 0;
    }

    static int ETV(int Zug)
    {
    if (Zug == 1)
    return 15;
    else if (Zug == 2)
    return 35;
    else if (Zug == 3)
    return 70;
    else
    return 0;
    }
    }
    }


    Download *click*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Dschungelflamme ()

  • Dschungelflamme schrieb:

    Also, hier ist der Code (jaa ich weiss man hätte es um einiges besser machen können und jaa, ich weiss, ich hab VIEL zu viel Variablen verwendet, aber es funktioniert xD)

    Gibt schlimmeres. Hättest du goto verwendet, dann hätte ich dir jetzt den Kopf abreisen müssen. ;)
    Du musst dich langsam rantasten, und dafür ist das echt okay. Mein erstes Programm sah so ähnlich aus, heute schreibe ich auch ein bisschen anders. ;)
    Du bist jetzt schon weiter als meine ehemaligen Klassenkameraden. Bei uns im Informatikunterricht ging es von Anfang an darum, alles perfekt zu machen. Das kann man beim schreiben lernen machen lassen, weil da die Regeln wichtig sind (ich erinnere mich, mal von einer Studie gehört zu haben, die besagt, dass dieses "Freie Schreiben", wie es an einigen Schulen durchgeführt wird, das ganze im Endeffekt erschwert). Beim Programmieren ist es genau anders rum. Erstmal ein Programm fertig stellen, und wenn es läuft, kann man es weiter modifizieren. Ich schreibe im Moment ein Komprimierprogramm. Den Komprimiervorgang habe ich bereits drei oder vier mal neu geschrieben um ihn zu optimieren. Aktuell bin ich bei ca. 10 Minuten um 1 GB zu dekomprimieren, bzw. ein bis drei Minuten (weiß die genaue Dauer jetzt nicht) um 1 GB zu komprimieren. Das ist zwar für mich ausreichend, aber ich werde es wohl definitiv noch zwei bis dreimal neu schreiben. Und selbst dann kann es sein, dass ich etwas neues lerne oder finde, was meinen alten Code komplett über den Haufen werfen wird.

    Also mach dir keinen Stress, in ein paar Wochen wirst du dir den Code nochmal anschauen und wirst dir an die Stirn langen und unfassbar drein schauen, wenn du merkst, wie aufgebläht dein kleines Spiel doch programmiert wurde. :D
    You like music? I like pissing.
    ~Corey Taylor
  • Naja, Spaghetticode vom feinsten, aber es gibt definitv schlimmeres. Ich meine, sah bei meinen ersten Versuchen auch nicht anders aus. :D

    Was bei dir als nächstes anstehen sollte, sind einfache Klassen und Objekte. Dann lassen sich solche Deklarationsorgien wie...

    Quellcode

    1. Random RndmAddition0 = new Random();
    2. Random RndmEAddition0 = new Random();
    3. Random RndmVerteidigung0 = new Random();
    4. Random RndmEVerteidigung0 = new Random();
    5. int RndmAddition1 = 0;
    6. int RndmEAddition1 = 0;
    7. int RndmVerteidigung1 = 0;
    8. int RndmEVerteidigung1 = 0;


    ... diese hier effektiv vermeiden und man erhält v.a. Code, den man wiederverwenden kann.
    Wobei man die Schwierigkeit, sauber objektorientiert zu programmieren, nicht unterschätzen sollte. Da bin ich auch mit 8 Jahren Programmiererfahrung wirklich kein Profi drin, also nicht verzweifeln, wenn du öfter mal was über den Haufen werfen musst ;)

    Und selbst dann kann es sein, dass ich etwas neues lerne oder finde, was meinen alten Code komplett über den Haufen werfen wird.

    Die zeitkritischen Teile einfach mit Hilfe des Software Optimization Guides für die jeweilige CPU in Assembler schreiben. Macht definitiv Spaß und man lernt ne Menge über die internen Vorgänge in so einer CPU. Und wenn du es richtig machst, geht dein Code ab wie Schmidts Katze, da kann dein Compiler nur blöd gucken :D

    Gibt schlimmeres. Hättest du goto verwendet, dann hätte ich dir jetzt den Kopf abreisen müssen. ;)

    Also goto hat durchaus seine Daseinsberechtigung - allerdings doch eher in low level-Code, den man in C# schlicht und ergreifend nicht schreiben kann.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von VikingGe ()

  • VikingGe schrieb:

    Also goto hat durchaus seine Daseinsberechtigung - allerdings doch eher in low level-Code, den man in C# schlicht und ergreifend nicht schreiben kann.

    Ja. Aber nicht in C#. Wir hatten eine C#-Schulung, und einer der Fachinformatiker, seines Zeichens Systemintegrator, hatte einen PHP-Blackjack-Code auf C# übertragen - mit Goto und allem drum und dran, obwohl sowohl C# als auch PHP Funktionen / Methoden beherrschen. Ich war kurz davor, ihn aus dem Fenster zu schmeißen, als ich den Code gesehen habe - die Schulung fand im vierten Stock statt. :D

    VikingGe schrieb:

    Was bei dir als nächstes anstehen sollte, sind einfache Klassen und Objekte. Dann lassen sich solche Deklarationsorgien wie...

    Wäre sinnvoll, ja. Zumindest ein bisschen Objektorientierung wäre sinnvoll. Im Endeffekt habe ich die damals ziemlich genial gelernt, nämlich mit VB5. Dort einfach eine Forms-Anwendung, und logischerweise war dann so was ähnliches wie Objektorientierung dabei - die Form ist ja auch ein Objekt, andere Sachen (Picture-Boxen, Buttons usw) auch. Hach ja, das war damals geil. Es hat mir jedenfalls wirklich geholfen, als ich später in Java wirklich "Hardcore-OoP" gelernt hatte. Gab allerdings auch welche, die meinten, VB5 hätte ihnen Java total versaut. Ist also ein zweischneidiges Schwert gewesen. :D

    VikingGe schrieb:

    Die zeitkritischen Teile einfach mit Hilfe des Software Optimization Guides für die jeweilige CPU in Assembler schreiben. Macht definitiv Spaß und man lernt ne Menge über die internen Vorgänge in so einer CPU. Und wenn du es richtig machst, geht dein Code ab wie Schmidts Katze, da kann dein Compiler nur blöd gucken

    Na super, jetzt kann ich meinen Code erneut neuschreiben. :D
    Nee, ich werde es mir mal merken. Aktuell bin ich beim Multithreading, damit das Teil nach Möglichkeit ordentlich abgeht. ;)
    You like music? I like pissing.
    ~Corey Taylor
  • Stück für Stück. Wenn er damit erst angefangen hat, lasst ihn erst mal so weitermachen. Was bringt es ihm jetzt mit anderen Sachen noch den Kopf zu verwirren. Als erstes sollte man das Basisprogrammieren lernen. Das macht er ja gerade. Eventuell das er Funktionen verwendet schon wenn überhaupt.

    Objektorientiert kann man für ihn erst recht verwirrend werden wenn er jetzt damit anfäng. Abstraktionen, Vererbungen, Persistenzen etc wären als Anfänger vllt etwas zu komplex wenn man das Grundwissen dazu noch gar nicht richtig beherscht.

    Das kommt nachher von ganz alleine. Ich hab mit 10 oder 11 angefangen Textadventures zu programmieren. Sogar mit Kampfsystem etc. Das ganze war basierend auf ein Buch aufgebaut. Ich hab es aber damals nur bis zur Hälfte geproggt gehabt. Hatte aber schon eine Save und Ladefunktion sowie ein Coursor zur Auswahl der Menüpunkte unter DOS.

    Klassen und Co. kamen erst später hinzu und ich musste das auch erst mal verstehen.

    Beispiel für eine 3D Punkt Klassifizierung:

    Quellcode

    1. TYPE Punkt3d
    2. x AS SINGLE
    3. y AS SINGLE
    4. z AS SINGLE
    5. END TYPE
    6. TYPE Facetri3D
    7. p1 AS Punkt3d
    8. p2 AS Punkt3d
    9. p3 AS Punkt3d
    10. END TYPE
    11. TYPE Vektor3D
    12. x AS SINGLE
    13. y AS SINGLE
    14. z AS SINGLE
    15. END TYPE
    Alles anzeigen


    Dann erfolgt die Klassifizierung der Kamera aus der Position mit der Klasse Punkt3D, der Richtung mit der Klasse Vektor3D und noch mal x y z als Rotations Angaben.

    Danach baut man sich daraus seine Engine auf. Eine 3D Engine die auf eine 2D Umgebung läuft wie halt unter DOS ^^

    Objekte wären dann halt Verschiebung, Skalieren, Rotieren, Kamera und ein Zeichnen Objekt.

    Ein paar Strahlensätze und Vektorenberechnungen angewandt und schon hat man seine 3D Engine in eine Programmiersprache die eigentlich kein 3D Ursprünglich kann ^^

    Getestet mit QB, C++, VB, Java, C# und noch einigen anderen Sprachen. Das Schema ist eigentlich fast immer identisch ^^

    Bei ner GUI muss man halt ein wenig mehr machen, sollte aber wenn man ne gute Vorstellung hat gar kein Problem sein. Ich finde GUI Programmierung gar nicht so schlimm wie ihr immer schreibt. Es ist nur ein bisschen mehr Arbeit. Mehr nicht.

    Und ich denke wenn er jetzt mit GUI anfängt, obwohl er gerade mal die Grundstruktur erlernt wird das recht verwirrend werden. ^^

    Objektorientiert heißt nicht das ich jetzt optische Objekte habe die ich irgendwo sehen kann, sondern ledeglich das ich bestimmte Routinen und Prozesse via Objekt besser verwalten kann. Wie halt die Abstraktion von Klassen und Modulen oder Verkapselungen, Vererbungen etc. Das ist Objektorientierte Programmierung. Und das kann ziemlich verwirrend werden.

    Objektorientiert konnte man schon unter DOS oder Unix wo noch kein GUI OS drauf war ^^ Weil es halt auch Anwendungen gab wie dieses hier: Bild

    Man konnte sich halt aus ASCII Zeichen ein komplettes GUI System zusammenbauen das so funktionierte wie man es halt auch unter Windows kennt. ^^

    Und das ist halt extrem schwierig.

    Vorgefertigte Objekte gabs damals noch nicht und man musste sich aus Klassen und den ganzen anderen drum herrum der zur Verfügung stand. sich seine Objekte selbst zusammenbauen. Und das ist wie gesagt die beste Methode um es zu verstehen und zu lernen. Was nützen mit Vorgefertigte Objekte die ich nur noch anzusprechen brauch, aber den Sinn nicht verstehe warum es eigentlich das macht was es soll? ^^ Das kann man später machen. Es ist zwars auch schnell gelernt, aber in der Umgebung mit der er jetzt ist, lernt er in meinen Augen am meisten mit den Schwächen und aber auch Vorteilen der CLI Umgebung.

    Probleme wie Umlaute, anderer ASCII Zeichensatz als Windows und und und... wird er als Probleme dort zu lösen haben, will er etwas gescheites umsetzen das auch unter Windows laufen soll. Angefangen mit der Speicherung von Datein oder das Laden halt.

    Ist so mein Aspekt mal wie ich das sehe. Klar, Java oder .Net Programmierung sind schon was tolles. Aber was nützt mir die professionellste Umgebung wenn mich der gesamte Aufbau der Umgebung schon regelrecht überfordert? ^^
    Ich denke VB oder Delphi wären da noch die einfachsten Sachen wenn es um GUI Programmierung geht ^^
  • Ich sehe das insgesamt wie meine Vorposter. ^^ Frei nach dem Motto: Probieren geht über Studieren!


    Generell empfehle ich dir jedoch, dich vor der weiteren Entwicklung des Projekts zumindest in die Grundzüge der Objektorientierung, der Zugriffsmodifizierer etc. einzulesen (Stichwort: Galileo Computing :D); vieles, was du jetzt noch über dutzende Variablen und Objekten in einer Klasse löst, ist damit deutlich eleganter und übersichtlicher möglich. Es führen zwar viele Wege nach Rom, aber warum gerade den Umständlichsten nehmen? ^^

    Außerdem solltest du dir, insbesondere wenn du anderen deinen Quellcode zeigst/zur Verfügung stellst, bestimmte Konventionen angewöhnen. Damit erleichterst du diesen Leuten das grundlegende Verständnis des Quellcodes immens, da beispielsweise Deklarationen auf den ersten Blick leichter verständlich sind.

    Das Argument des GUI kann ich nicht nachvollziehen; programmieren mit einem GUI setzt teilweise erheblich mehr Verständnis der Sprache voraus als simple CLI Programmierung. Ich kenne teilweise Leute, die gleich mit GUIs begonnen haben und später keine Ahnung hatten, für was die Event-Parameter in den GUI-bezogenen Methoden gut sind. Lieber erst einmal den Sinn hinter den ganzen Elementen der Sprache kennen und sich dann langsam hocharbeiten.

    Ich programmiere ja selbst in C# und kenne dadurch deine Ungeduld, sich nicht erst mit den langweiligen Kleinigkeiten auseinanderzusetzen, sondern sofort loszulegen. Aber bildlich gesprochen sind gerade diese kleinen Bausteine sehr wichtig, da ohne sie Spalträume zwischen den größeren Bausteinen entstehen und das Projekt schließlich zusammenstürzt.