Stein, Papier, Schere, Echse, Spock

10 Lösungen

#106

Anfänger - C# von Energy - 24.09.2015 um 15:22 Uhr

Programmiere das Spiel Stein, Papier, Schere, Echse, Spock, sodass man selbst eine Figur auswählen kann und der Computer eine zufällige Figur auswählt. Ermittele dann, wer diese Partie gewonnen hat.

Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.

Frage stellen

Bitte melden Sie sich an um eine Lösung einzureichen.

Lösung einreichen

von Mexx (2370 Punkte) - 21.10.2015 um 13:20 Uhr

Hier mal eine GUI-Version

Vorschau:
http://www.xup.in/dl,14667007/spses.jpg/

C#-Code

using System;
using System.Drawing;

namespace SPSES
{
    public partial class Form1 : Form
    {
        TypOfHand userHand;
        TypOfHand kiHand;

        public Form1()
        {
            InitializeComponent();
            lblWinner.Visible = false;
            lblYou.Visible = false;
            lblComputer.Visible = false;
        }

        private void Image_Click(object sender, EventArgs e)
        {
            lblWinner.Visible = false;
            lblYou.Visible = false;
            lblComputer.Visible = false;
            PictureBox box = (PictureBox)sender;
            switch (box.Name)
            {
                case "pbStein":
                    userHand = new TypOfHand((byte)EHand.Stein);
                    break;
                case "pbPapier":
                    userHand = new TypOfHand((byte)EHand.Papier);
                    break;
                case "pbScheere":
                    userHand = new TypOfHand((byte)EHand.Scheere);
                    break;
                case "pbEchse":
                    userHand = new TypOfHand((byte)EHand.Echse);
                    break;
                case "pbSpock":
                    userHand = new TypOfHand((byte)EHand.Spock);
                    break;
                default:
                    userHand = null;
                    break;
            }

            if (userHand == null)
                throw new ArgumentNullException("Ihre Auswahl konnte nicht ermittelt werden");

            pbUserHand.BackgroundImage = userHand.bild;
            Random ran = new Random();
            byte randomHand = (byte)Math.Pow(2, ran.Next(0, 5));
            kiHand = new TypOfHand(randomHand);
            pbKiHand.BackgroundImage = kiHand.bild;
            lblWinner.Text = Kominationen.GetKombo((byte)(userHand.typ | kiHand.typ));
            Sieger sieg = new Sieger(userHand.typ, kiHand.typ);
            if (sieg.GetSieger() == "spieler")
            {   // User gewinnt
                lblYou.Text = "Gewonnen";
                lblComputer.Text = "Verloren";
                lblYou.Visible = true;
                lblComputer.Visible = true;
            }
            else if (sieg.GetSieger() == "ki")
            {   // KI gewinnt
                lblYou.Text = "Verloren";
                lblComputer.Text = "Gewonnen";
                lblYou.Visible = true;
                lblComputer.Visible = true;
            }
            else
            {   // Unentschieden
                lblYou.Text = "~";
                lblComputer.Text = "~";
                lblYou.Visible = true;
                lblComputer.Visible = true;
            }
            lblWinner.Visible = true;
        }
    }
}

C#-Code

using System;
using System.Collections.Generic;
using System.Drawing;

namespace SPSES
{
    class TypOfHand
    {
        /// <summary>
        /// Typ der gewählten Hand
        /// </summary>
        public byte typ { get; private set; }
        /// <summary>
        /// Ein Bild welches die Hand darstellt
        /// </summary>
        public Image bild { get; private set; }

        public Dictionary<byte, Image> ImagesFromByte { get; private set; }

        public TypOfHand(byte typ)
        {
            ImagesFromByte = new Dictionary<byte, Image>()
            {
                { (byte)EHand.Stein, (Image)SPSES.Properties.Resources.Stein },
                { (byte)EHand.Papier, (Image)SPSES.Properties.Resources.Papier },
                { (byte)EHand.Scheere, (Image)SPSES.Properties.Resources.Scheere },
                { (byte)EHand.Echse, (Image)SPSES.Properties.Resources.Echse },
                { (byte)EHand.Spock, (Image)SPSES.Properties.Resources.Spock }
            };
            this.typ = typ;
            this.bild = ImagesFromByte[typ];
        }
    }
    
    public class Kominationen
    {
        #region Dictionarys
        static readonly Dictionary<byte, string> KombosFromByte = new Dictionary<byte, string>()
        {
            { (byte)(EHand.Stein | EHand.Stein),    "      Unentschieden     " },
            { (byte)(EHand.Stein | EHand.Papier),   " Papier umwickelt Stein " },
            { (byte)(EHand.Stein | EHand.Scheere),  "Stein zerschlägt Scheere" },
            { (byte)(EHand.Stein | EHand.Echse),    "Stein zerquetscht Echse " },
            { (byte)(EHand.Stein | EHand.Spock),    " Spock verdampft Stein  " },
            { (byte)(EHand.Papier | EHand.Papier),  "      Unentschieden     " },
            { (byte)(EHand.Papier | EHand.Scheere), "Scheere schneidet Papier" },
            { (byte)(EHand.Papier | EHand.Echse),   "  Echse frisst Papier   " },
            { (byte)(EHand.Papier | EHand.Spock),   "Papier wiederlegt Spock " },
            { (byte)(EHand.Scheere | EHand.Scheere),"      Unentschieden     " },
            { (byte)(EHand.Scheere | EHand.Echse),  "  Scheere köpft Echse   " },
            { (byte)(EHand.Scheere | EHand.Spock),  " Spock zerlegt Scheere  " },
            { (byte)(EHand.Echse | EHand.Echse),    "      Unentschieden     " },
            { (byte)(EHand.Echse | EHand.Spock),    " Echse vergiftet Spock  " },
            { (byte)(EHand.Spock | EHand.Spock),    "      Unentschieden     " }
        };
        #endregion

        public static string GetKombo(byte kombo)
        {
            return KombosFromByte[kombo];
        }
    }

    public class Sieger
    {
        byte spieler;
        byte ki;

        public Sieger(byte spieler, byte ki)
        {
            this.spieler = spieler;
            this.ki = ki;
        }

        /// <summary>
        /// Ermittelt den Sieger der Runde
        /// </summary>
        /// <returns>"spieler", "ki" oder "unentschieden"</returns>
        public string GetSieger()
        {
            byte kombo = (byte)(spieler | ki);

            if (kombo == 5 || kombo == 9)
                //Stein gewinnt
                if (spieler == (byte)EHand.Stein)
                    return "spieler";
                else
                    return "ki";
            else if (kombo == 3 || kombo == 18)
                // Papier gewinnt
                if (spieler == (byte)EHand.Papier)
                    return "spieler";
                else
                    return "ki";
            else if (kombo == 6 || kombo == 12)
                // Scheere gewinnt
                if (spieler == (byte)EHand.Scheere)
                    return "spieler";
                else
                    return "ki";
            else if (kombo == 10 || kombo == 24)
                // Echse gewinnt
                if (spieler == (byte)EHand.Echse)
                    return "spieler";
                else
                    return "ki";
            else if (kombo == 17 || kombo == 20)
                // Spock gewinnt
                if (spieler == (byte)EHand.Spock)
                    return "spieler";
                else
                    return "ki";
            else if (kombo == 1 || kombo == 2 || kombo == 4 || kombo == 8 || kombo == 16)
                return "unentschieden";
            else
                throw new Exception("Sieger konnte nicht ermittelt werden");
        }
    }
    
    [Flags]
    public enum EHand
    {
        None = 0,
        Stein = 1 << 0,
        Papier = 1 << 1,
        Scheere = 1 << 2,
        Echse = 1 << 3,
        Spock = 1 << 4

    }
}