示例#1
0
 public void spielerGehtRechts(Spieler Spieler1, Karte Karte)
 {
     Console.MoveBufferArea(Spieler1.getxSpielerPos, Spieler1.getySpielerPos, 1, 1, Spieler1.getxSpielerPos + 1, Spieler1.getySpielerPos);
     Console.SetCursorPosition(Spieler1.getxSpielerPos, Spieler1.getySpielerPos);
     Karte.feldStatus[Spieler1.getySpielerPos, Spieler1.getxSpielerPos + 1] = 0;
     Spieler1.setXSpielerPos = Spieler1.getxSpielerPos + 1;
 }
示例#2
0
        //Spieler bewegung

        public void spielerGehtHoch(Spieler Spieler1, Karte Karte)
        {
            Console.MoveBufferArea(Spieler1.getxSpielerPos, Spieler1.getySpielerPos, 1, 1, Spieler1.getxSpielerPos, Spieler1.getySpielerPos - 1);
            Console.SetCursorPosition(Spieler1.getxSpielerPos, Spieler1.getySpielerPos);
            Karte.feldStatus[Spieler1.getySpielerPos - 1, Spieler1.getxSpielerPos] = 0;
            Spieler1.setYSpielerPos = Spieler1.getySpielerPos - 1;
        }
示例#3
0
        public void feldPrüfen(Spieler Spieler1, Karte Karte, HeldStatus HUD, Gegenstande Inventar, Eventhandler Events, int feldnummer)
        {
            switch (feldnummer)

            {
            case 0: break;

            case 1: break;

            case 2: Spieler1.sammelMunze(HUD, Spieler1, Inventar); Karte.feldMenge--; break;

            case 3: Spieler1.sammelHP(HUD, Spieler1, Inventar); Karte.feldMenge--; break;

            case 4: Events.starteKampf(Spieler1, Inventar, HUD, Karte); Karte.zeichneKarte(); zeichneSpielerPos(Spieler1); Karte.feldMenge--; break;
            }



            if (Karte.feldMenge <= 0)
            {
                Karte.initKarte(Events, HUD);
                Karte.zeichneKarte();
                zeichneSpielerPos(Spieler1);
            }
        }
示例#4
0
        //Kampfsystem

        public void starteKampf(Spieler Spieler1, Gegenstande Inventar, HeldStatus HUD, Karte Karte)
        {
            //Kampf Initsialisieren Objekte erstellen Werte zuweisen

            Boolean        istImKampf         = true;
            Random         randMonsterSchaden = new Random();
            Random         randSchaden        = new Random();
            Random         randBlockchance    = new Random();
            Gegner         Monster            = new Gegner();
            ConsoleKeyInfo taste;

            Monster.erstelleMonster(Monster, Karte.Level);

            //Kampfwerte Übergeben

            int SpielerHP      = Spieler1.getSpielerLeben;
            int SpielerMaxHP   = Spieler1.getSpielerMaxLeben + Spieler1.getSpielerRingHP;
            int SpielerArmor   = Spieler1.getSpielerArmor;
            int SpielerAngriff = Spieler1.getSpielerAngriff + Spieler1.getSpielerWaffe;



            //Monster Werte

            int    MonsterHP      = Monster.getMonsterHP;
            int    MonsterMaxHP   = Monster.getMonsterMaxHP;
            int    MonsterAngriff = Monster.getMonsterAngriff;
            String MonsterTyp     = Monster.getMonsterTyp;
            int    MonsterKrit    = 0;



            //StartText

            HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerAngriff, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterAngriff, 1);

            //Monster erstellen

            while (istImKampf == true)
            {
                //Kritschischer Treffer


                taste = Console.ReadKey();

                switch (taste.Key)
                {
                //Angriff !

                case ConsoleKey.A:

                    //Spielerschaden

                    int SpielerSchaden = SpielerAngriff + randSchaden.Next(1, 5);

                    MonsterHP = MonsterHP - SpielerSchaden;
                    HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerSchaden, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterAngriff, 2);

                    //Monsterschaden

                    int MonsterSchaden = MonsterAngriff + randMonsterSchaden.Next(1, 5) - SpielerArmor;

                    if (MonsterKrit == 5)
                    {
                        MonsterSchaden = 5 + Convert.ToInt32(MonsterSchaden * 1.5);
                    }

                    if (MonsterSchaden <= 0)
                    {
                        MonsterSchaden = 0;
                    }
                    SpielerHP = SpielerHP - MonsterSchaden;

                    //HUD Aktualisieren

                    HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerSchaden, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterSchaden, 3);


                    break;

                //Verteidigen


                case ConsoleKey.D:

                    int Block = randBlockchance.Next(1, 5);
                    int SpielerSchadenBlock = SpielerAngriff + randSchaden.Next(1, 3);
                    int MonsterSchadenBlock = MonsterAngriff + randMonsterSchaden.Next(1, 5) - SpielerArmor;

                    switch (Block)
                    {
                    //Fall nicht geblockt !

                    case 1:

                        MonsterSchadenBlock = MonsterAngriff + randMonsterSchaden.Next(1, 5) - SpielerArmor;

                        //Bei Krit Schaden erhöhen

                        if (MonsterKrit == 5)
                        {
                            MonsterSchadenBlock = MonsterSchadenBlock * 2;
                        }

                        if (MonsterSchadenBlock <= 0)
                        {
                            MonsterSchadenBlock = 0;
                        }


                        SpielerHP = SpielerHP - MonsterSchadenBlock;

                        //HUD Aktualisieren

                        HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerSchadenBlock, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterSchadenBlock, 6); break;

                    //Fall geblockt !

                    default:

                        MonsterSchadenBlock = randBlockchance.Next(1, 5);
                        MonsterHP           = MonsterHP - MonsterSchadenBlock;
                        HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerSchadenBlock, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterSchadenBlock, 5);
                        HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerSchadenBlock, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterSchadenBlock, 1); break;
                    }
                    break;
                }

                HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerAngriff, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterAngriff, 1);

                //Gewonnen oder verloren

                if (SpielerHP <= 0)
                {
                    Console.Clear();
                    HighScore Spiel = new HighScore();
                    Spiel.dateiErstellen(Spieler1, Spieler1.getPunktZahl);
                    Spiel.dateiLesen(Spieler1);
                    System.Environment.Exit(0);
                }

                if (MonsterHP <= 0)
                {
                    //Game Over

                    if (SpielerHP <= 0)
                    {
                        Console.Clear();
                        HighScore Spiel = new HighScore();
                        Spiel.dateiErstellen(Spieler1, Spieler1.getPunktZahl);
                        Spiel.dateiLesen(Spieler1);
                        System.Environment.Exit(0);
                    }
                    Spieler1.setSpielerLeben = SpielerHP;
                    HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, SpielerAngriff, MonsterHP, MonsterMaxHP, MonsterTyp, MonsterAngriff, 4);

                    int Erfahrung = Convert.ToInt32(Karte.Level);

                    Spieler1.setSpielerErfahrung = Spieler1.getSpielerErfahrung + Erfahrung;
                    Spieler1.setPunktzahl        = Spieler1.getPunktZahl + 5 + Erfahrung;
                    Spieler1.levelUP(Spieler1);
                    HUD.zeichneHud(Spieler1, Inventar);
                    break;
                }

                //Crit oder kein Crit

                MonsterKrit = randMonsterSchaden.Next(1, 7);

                if (MonsterKrit == 5)
                {
                    HUD.erstelleKampftext(SpielerHP, SpielerMaxHP, 0, MonsterHP, MonsterMaxHP, MonsterTyp, 0, 7);
                }
            }

            //Game Over

            if (SpielerHP <= 0)
            {
                Console.Clear();
                HighScore Spiel = new HighScore();
                Spiel.dateiErstellen(Spieler1, Spieler1.getPunktZahl);
                Spiel.dateiLesen(Spieler1);
                System.Environment.Exit(0);
            }
        }
示例#5
0
        //Grundlegendes Menü aufbauen

        public void initStartMenu(Menu Startmenu)
        {
            while (istImStartMenu == true)
            {
                Console.Clear();
                Console.SetCursorPosition(26, 4);
                Console.WriteLine("Willkommen beim Pixel Doom");
                Console.SetCursorPosition(28, 14);
                Console.WriteLine("[ 1 ]-Neues Spiel");
                Console.SetCursorPosition(28, 15);
                Console.WriteLine("[ 2 ]-Highscore");
                Console.SetCursorPosition(28, 16);
                Console.WriteLine("[ 3 ]-Exit");
                Console.SetCursorPosition(46, 35);
                Console.WriteLine("Produziert von Michael Börner");
                Console.SetCursorPosition(5, 35);
                Console.WriteLine("Alle Rechte Vorbehalten");

                //Switch Auswahl

                string menuAuswahl;
                Console.SetCursorPosition(26, 23);
                Console.Write("Bitte Auswahl eingeben: ");
                menuAuswahl = Console.ReadLine();

                switch (menuAuswahl)
                {
                case "1":

                    //ALLE OBJEKTE ERSTELLEN FÜR DEN START

                    Karte         Karte         = new Karte(20, 40, 20, 20); //Kartenhöhe Kartenbreite und Cursor X Y
                    HeldStatus    HUD           = new HeldStatus(20, 40);
                    Eventhandler  Events        = new Eventhandler();
                    Hauptschleife Spielschleife = new Hauptschleife();
                    Spieler       Spieler1      = new Spieler();
                    Gegenstande   Inventar      = new Gegenstande();
                    HighScore     Punkte        = new HighScore();
                    Shop          Kaufen        = new Shop();


                    Karte.initKarte(Events, HUD);
                    Karte.zeichneKarte();
                    HUD.zeichneHud(Spieler1, Inventar);
                    Spielschleife.spielSchleife(Karte, HUD, Events, Spieler1, Startmenu, Inventar, Kaufen);
                    break;

                //Highscore

                case "2":

                    Console.Clear();
                    Spieler   Spieler2       = new Spieler();
                    HighScore punkteAbfragen = new HighScore();
                    punkteAbfragen.dateiLesen(Spieler2);
                    Console.ReadKey();

                    break;

                case "3":

                    System.Environment.Exit(0);

                    break;

                default: break;
                }
            }
        }
示例#6
0
        public void spielSchleife(Karte Karte, HeldStatus HUD, Eventhandler Events, Spieler Spieler1, Menu Startmenu, Gegenstande Inventar, Shop Kaufen)
        {
            //Spieler1 Start Werte

            Console.SetCursorPosition(1, 1);
            Spieler1.setXSpielerPos = 1;
            Spieler1.setYSpielerPos = 1;
            Console.Write("@");

            while (istSpielAktiv == true)
            {
                //Tasten Abfragen
                Console.SetCursorPosition(1, 22);
                ConsoleKeyInfo taste;
                taste = Console.ReadKey();
                HUD.zeichneHud(Spieler1, Inventar);


                switch (taste.Key)
                {
                //Pfeil Rauf

                case ConsoleKey.UpArrow:

                    switch (Karte.feldStatus[Spieler1.getySpielerPos - 1, Spieler1.getxSpielerPos])
                    {
                    case 0: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 0); Spieler1.spielerGehtHoch(Spieler1, Karte); break;

                    case 1: break;

                    case 2: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 2); Spieler1.spielerGehtHoch(Spieler1, Karte); break;

                    case 3: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 3); Spieler1.spielerGehtHoch(Spieler1, Karte); break;

                    case 4: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 4); Spieler1.spielerGehtHoch(Spieler1, Karte); break;
                    }
                    break;


                //Pfeil Runter

                case ConsoleKey.DownArrow:

                    switch (Karte.feldStatus[Spieler1.getySpielerPos + 1, Spieler1.getxSpielerPos])
                    {
                    case 0: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 0); Spieler1.spielerGehtRunter(Spieler1, Karte); break;

                    case 1: break;

                    case 2: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 2); Spieler1.spielerGehtRunter(Spieler1, Karte); break;

                    case 3: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 3); Spieler1.spielerGehtRunter(Spieler1, Karte); break;

                    case 4: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 4); Spieler1.spielerGehtRunter(Spieler1, Karte); break;
                    }
                    break;


                //Pfeil Links

                case ConsoleKey.LeftArrow:

                    switch (Karte.feldStatus[Spieler1.getySpielerPos, Spieler1.getxSpielerPos - 1])
                    {
                    case 0: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 0); Spieler1.spielerGehtLinks(Spieler1, Karte); break;

                    case 1: break;

                    case 2: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 2); Spieler1.spielerGehtLinks(Spieler1, Karte); break;

                    case 3: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 3); Spieler1.spielerGehtLinks(Spieler1, Karte); break;

                    case 4: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 4); Spieler1.spielerGehtLinks(Spieler1, Karte); break;
                    }
                    break;

                //Pfeil Rechts

                case ConsoleKey.RightArrow:

                    switch (Karte.feldStatus[Spieler1.getySpielerPos, Spieler1.getxSpielerPos + 1])
                    {
                    case 0: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 0); Spieler1.spielerGehtRechts(Spieler1, Karte); break;

                    case 1: break;

                    case 2: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 2); Spieler1.spielerGehtRechts(Spieler1, Karte); break;

                    case 3: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 3); Spieler1.spielerGehtRechts(Spieler1, Karte); break;

                    case 4: feldPrüfen(Spieler1, Karte, HUD, Inventar, Events, 4); Spieler1.spielerGehtRechts(Spieler1, Karte); break;
                    }
                    break;

                //Austrüstungs Auswahl

                case ConsoleKey.W: Inventar.selectWeapon(HUD, Spieler1); HUD.zeichneHud(Spieler1, Inventar); Karte.zeichneKarte(); zeichneSpielerPos(Spieler1); break;

                case ConsoleKey.A: Inventar.selectArmor(HUD, Spieler1); HUD.zeichneHud(Spieler1, Inventar); Karte.zeichneKarte(); zeichneSpielerPos(Spieler1); break;

                case ConsoleKey.R: Inventar.selectRing(HUD, Spieler1); HUD.zeichneHud(Spieler1, Inventar); Karte.zeichneKarte(); zeichneSpielerPos(Spieler1); break;

                case ConsoleKey.E: Kaufen.verkaufeItem(Spieler1, Inventar); HUD.zeichneHud(Spieler1, Inventar); Karte.zeichneKarte(); zeichneSpielerPos(Spieler1);
                    Inventar.selectArmor(HUD, Spieler1);
                    Inventar.selectWeapon(HUD, Spieler1);
                    Inventar.selectRing(HUD, Spieler1); break;
                }
            }
        }