Exemplo n.º 1
0
        public override List <Feld> Schlagen(Feld vonFeld, Feld zuFeld, Spieler s, Brett brett)
        {
            schlagFlag          = false;
            doppelDameFlag      = false;
            zuSchlagendeFelder  = new List <Feld>();
            startSteinBesetzung = null;


            // Nur was machen, wenn auf dem startfeld wirklich ein stein liegt und auf dem Ziel keiner liegt
            if (vonFeld.GetSteinBesetzung() != null && zuFeld.GetSteinBesetzung() == null)
            {
                startSteinBesetzung = vonFeld.GetSteinBesetzung();
                this.Search(vonFeld, zuFeld, s, brett); //setzt zuSchlagendeFelder
                doppelDameFlag = false;
            }

            if (zuSchlagendeFelder.Count < 1 || zuSchlagendeFelder[0] == null)
            {
                zuSchlagendeFelder = null;
            }
            startSteinBesetzung = null;


            return(zuSchlagendeFelder);
        }
Exemplo n.º 2
0
        // Mouse clicked on the Board. Make clicked field either the start or target
        void OnMouseDown()
        {
            // Only react on Mouse click if the Pause menu is not open
            if (!MenuBackground.activeSelf && (self == null || (self.GetFarbe() == aktuellerSpieler.GetFarbe())))
            {
                float hitdistance = 0.0f;
                Ray   ray         = Camera.main.ScreenPointToRay(Input.mousePosition);
                Plane plane       = new Plane(transform.up, transform.position);

                if (plane.Raycast(ray, out hitdistance))
                {
                    Vector3 hitPoint = ray.GetPoint(hitdistance);
                    Feld    newFeld  = this.brett.GetFelder()[(int)(hitPoint.x + 4), (int)(hitPoint.z + 4)];

                    // 1. Start noch nicht ausgewählt
                    if (vonFeld == null)
                    {
                        if (newFeld != null)
                        {
                            vonFeld = newFeld;

                            // 1.1 Start enthät stein
                            if (vonFeld.GetSteinBesetzung() != null)
                            {
                                if (vonFeld.GetSteinBesetzung().GetComponent <Stein>().GetFarbe() == aktuellerSpieler.GetFarbe())
                                {
                                    Debug.Log("Startfeld gesetzt.");
                                    // Mark respective fields (Visual feedback)
                                    List <Feld> moves = this.regelwerk.GetMoves(vonFeld, this.GetAktuellerSpieler(), this.brett);
                                    MarkFields(new List <Feld> {
                                        vonFeld
                                    }, Tag.Start);                                                   // Starting field
                                    MarkFields(moves, Tag.Ziel);                                     // Target fields

                                    // Lösche Marker (gelb)
                                    foreach (var marker in GameObject.FindGameObjectsWithTag("MarkerAvailable"))
                                    {
                                        Destroy(marker);
                                    }
                                }
                                else
                                {
                                    Debug.Log("Dies ist kein gültiges Feld.");
                                    vonFeld = null;
                                }
                            }
                            // 1.2 Start enthält keinen Stein
                            else
                            {
                                Debug.Log("Auf diesem Feld befindet sich kein Spielstein.");
                                vonFeld = null;
                            }
                        }
                        else
                        {
                            Debug.Log("Auswahl ungültig.");
                        }
                    }

                    // 2. Start ausgewählt, aber neue Auswahl == alte auswahl
                    else if (newFeld.GetPositionX() == vonFeld.GetPositionX() && newFeld.GetPositionY() == vonFeld.GetPositionY())
                    {
                        vonFeld = null;
                        Debug.Log("Auswahl deselektiert.");

                        // Lösche Marker (grün, cyan)
                        foreach (var marker in GameObject.FindGameObjectsWithTag("MarkerSelect"))
                        {
                            Destroy(marker);
                        }

                        // Erzeuge Marker (gelb)
                        MarkMovableTokens();
                    }

                    // 3. Start ausgewählt, Ziel noch nicht ausgewählt
                    else if (zuFeld == null)
                    {
                        zuFeld = this.brett.GetFelder()[(int)(hitPoint.x + 4), (int)(hitPoint.z + 4)];

                        // 3.1 Ziel enthält keinen anderen Stein
                        if (zuFeld.GetSteinBesetzung() == null)
                        {
                            if (zuFeld.GetFarbe() == Farbe.Schwarz)
                            {
                                Debug.Log("Zielfeld gesetzt.");
                                if (MoveStein(vonFeld, zuFeld))
                                {
                                    netzwerk.Send("move;" + vonFeld.GetPositionX() + "" + vonFeld.GetPositionY() + "" + zuFeld.GetPositionX() + "" + zuFeld.GetPositionY());

                                    vonFeld = zuFeld = null;

                                    // Lösche Marker (grün, cyan)
                                    foreach (var marker in GameObject.FindGameObjectsWithTag("MarkerSelect"))
                                    {
                                        Destroy(marker);
                                    }
                                }
                                else
                                {
                                    zuFeld = null;
                                }
                            }
                            else
                            {
                                Debug.Log("Dies ist kein gültiges Feld.");
                                zuFeld = null;
                            }
                        }

                        // 3.2 Ziel enthält einen Stein
                        else
                        {
                            Debug.Log("Auf diesem Feld befindet sich bereits ein Spielstein.");
                            zuFeld = null;
                        }
                    }
                }
            }
        }
Exemplo n.º 3
0
        //wird verwendet um seinen Stein zu bewegen
        public Boolean MoveStein(Feld vonFeld, Feld zuFeld)
        {
            bool        b        = false;   //boolean zum ziehen
            List <Feld> c        = null;    //boolean zum schlagen
            bool        wirdDame = false;

            /*
             *      if(vonFeldX<0||vonFeldX>this.brett.GetBreite() ||
             *         vonFeldY<0||vonFeldY>this.brett.GetHöhe() ||  unnötig
             *         zuFeldX<0||zuFeldX>this.brett.GetBreite() ||
             *         zuFeldY<0||zuFeldY>this.brett.GetHöhe()){
             *              b = false;  //Koordinaten stimmen nicht
             *
             *      }else{ }
             */


            /* TODO AUSKOMMENTIEREN      wird in regelwerk geregelt
             * if (this.aktuellerSpieler.GetFarbe() != vonFeld.GetSteinBesetzung().GetComponent<Stein>().GetFarbe())
             * {
             *      b = false;    //Spieler besitzt den Stein nicht bzw. den Stein auf diesem Feld gibt es nicht
             * }
             * else
             * { }
             */
            c = this.regelwerk.Schlagen(vonFeld, zuFeld, this.aktuellerSpieler, this.brett); //darf bzw. will ich schlagen?
            if (c != null)                                                                   //schlagen des Gegners
            {
                b = true;                                                                    //stein wird nachher verlegt
                GameObject.Find("Audio Source Jump").GetComponent <AudioSource>().Play();
            }
            else                //sonst muss man prüfen ob es ein normaler zug war
            {
                b = this.regelwerk.MoveStein(vonFeld, zuFeld, this.aktuellerSpieler, this.brett);
                if (b)
                {
                    GameObject.Find("Audio Source Move").GetComponent <AudioSource>().Play();
                }
            }

            if (b)                                                                  //verlegen des Steins   //gueltiger Zug
            {
                zuFeld.SetSteinBesetzung(vonFeld.GetSteinBesetzung());              //setze Stein auf neues Feld
                vonFeld.GetSteinBesetzung().GetComponent <Stein>().SetFeld(zuFeld); //setze neues Feld im Stein
                vonFeld.SetSteinBesetzung(null);                                    //loesche Stein von altem Feld
                if (c != null)
                {
                    foreach (Feld f in c)
                    {
                        if (f.GetSteinBesetzung() != null)
                        {
                            //Debug.Log("Geschlagener Stein wird entfernt");
                            if (f.GetSteinBesetzung().GetComponent <Stein>().GetFarbe() == Farbe.Schwarz)
                            {
                                GameObject.Find("BlackCountMessage").GetComponent <Text>().text = "Schwarz: " + --this.backCount;
                            }
                            else
                            {
                                GameObject.Find("WhiteCountMessage").GetComponent <Text>().text = "Weiß: " + --this.whiteCount;
                            }

                            f.GetSteinBesetzung().GetComponent <Stein>().SetFeld(null);                 //loeschen des Feldes des Steins
                            Destroy(f.GetSteinBesetzung().GetComponent <Stein>().transform.gameObject); // loeschen des Gameobjects
                            f.SetSteinBesetzung(null);                                                  //loeschen des Steins auf dem Feld

                            //Debug.Log("Geschlagener Stein wurde entfernt");
                        }
                    }
                }
                wirdDame = this.regelwerk.WirdZuDame(zuFeld, this.aktuellerSpieler);
                if (wirdDame)
                {
                    if (zuFeld.GetSteinBesetzung().GetComponent <Stein>().IsDame())
                    {
                        Debug.Log("Stein ist bereits Dame");
                    }
                    else
                    {
                        Debug.Log("Stein wird zu Dame");
                        zuFeld.GetSteinBesetzung().GetComponent <Stein>().SetDame();

                        GameObject.Find("Audio Source Dame").GetComponent <AudioSource>().Play();

                        /*/ ALTERNATIVE: Beim erstellen der Steine auch gleich allen ein Dame-Modell geben, dieses dann hier sichtbar schalten
                         * Stein steinSkript = zuFeld.GetSteinBesetzung().GetComponent<Stein>(); // get old script
                         * GameObject dame = Instantiate(Resources.Load("Dame")) as GameObject; // load new model
                         * dame.AddComponent<Stein>(); // add old script to new model
                         * dame.GetComponent<Stein>().instantiate(steinSkript.GetFarbe(), steinSkript.GetFeld());
                         * dame.GetComponent<Stein>().SetDame(true);
                         * Destroy(zuFeld.GetSteinBesetzung()); // delete old model (and script)
                         * zuFeld.SetSteinBesetzung(null);
                         * zuFeld.SetSteinBesetzung(dame); // put model on the board
                         */
                    }
                }



                this.HasWon();
                this.EndTurn();

                // Will break with board > 10
                // Example: move;7564
            }
            else
            {
                Debug.Log("Ungueltiger Zug");
            }

            return(b);
        }
Exemplo n.º 4
0
        public override Boolean MoveStein(Feld vonFeld, Feld zuFeld, Spieler s, Brett brett)
        {
            bool b = false;

            //Debug.Log("Ist Dame: " + vonFeld.GetSteinBesetzung().GetComponent<Stein>().IsDame());


            if (zuFeld.GetFarbe() == Farbe.Schwarz)                 //ist Zielfeld ueberhaupt Schwarz?
            {
                //DamenMove:
                if (vonFeld.GetSteinBesetzung().GetComponent <Stein>().IsDame() &&              //ist Stein Dame?
                    s.GetFarbe() == vonFeld.GetSteinBesetzung().GetComponent <Stein>().GetFarbe())                           //gehoert Stein zu aktuellem Spieler?
                {
                    Debug.Log("Dame darf ziehen");
                    for (int counter = 1; counter <= brett.GetBreite(); counter++)                       //Zaehle Felder ab falls jemand dazwischen TODO: 8 muss noch an flexible Brettlaenge angepasst werden
                    {
                        Debug.Log("zaehlt: " + counter);

                        /*if (vonFeld.GetPositionX() - counter < 0 || vonFeld.GetPositionY() - counter < 0
                        || vonFeld.GetPositionX() - counter > 8 || vonFeld.GetPositionY() - counter > 8)    //ist Zaehler noch auf dem Brett TODO: Brettgroesse
                        || {
                        || Debug.Log("Counter aus dem Zaehlerbereich");
                        || break;
                        || }*/
                        if (zuFeld.GetPositionX() < vonFeld.GetPositionX() && zuFeld.GetPositionY() < vonFeld.GetPositionY())                           //ist Feld links unten?
                        {
                            Debug.Log("Feld ist links unten");
                            if (vonFeld.GetPositionX() - counter >= 0 &&
                                vonFeld.GetPositionY() - counter >= 0 &&
                                brett.GetFelder()[vonFeld.GetPositionX() - counter, vonFeld.GetPositionY() - counter].GetSteinBesetzung() == null) //ist etwas im Weg?
                            {
                                if (zuFeld.GetPositionX() == vonFeld.GetPositionX() - counter &&                                                   //Stimmen zuFeldKoordinaten?
                                    zuFeld.GetPositionY() == vonFeld.GetPositionY() - counter)
                                {
                                    Debug.Log("Dame zieht");
                                    b = true;
                                    break;
                                }
                            }
                            else
                            {
                                Debug.Log("Stein im Weg");
                                break;
                            }
                        }
                        if (zuFeld.GetPositionX() > vonFeld.GetPositionX() && zuFeld.GetPositionY() > vonFeld.GetPositionY())                           //ist Feld rechts oben?
                        {
                            Debug.Log("Feld ist rechts oben");
                            if (vonFeld.GetPositionX() + counter < brett.GetBreite() &&
                                vonFeld.GetPositionY() + counter < brett.GetBreite() &&
                                brett.GetFelder()[vonFeld.GetPositionX() + counter, vonFeld.GetPositionY() + counter].GetSteinBesetzung() == null) //ist etwas im Weg?
                            {
                                if (zuFeld.GetPositionX() == vonFeld.GetPositionX() + counter &&                                                   //Stimmen zuFeldKoordinaten?
                                    zuFeld.GetPositionY() == vonFeld.GetPositionY() + counter)
                                {
                                    Debug.Log("Dame zieht");
                                    b = true;
                                    break;
                                }
                            }
                            else
                            {
                                Debug.Log("Stein im Weg");
                                break;
                            }
                        }
                        else if (zuFeld.GetPositionX() < vonFeld.GetPositionX() && zuFeld.GetPositionY() > vonFeld.GetPositionY())                           //ist Feld links oben?
                        {
                            Debug.Log("Feld ist links oben");
                            if (vonFeld.GetPositionX() - counter >= 0 &&
                                vonFeld.GetPositionY() + counter < brett.GetBreite() &&
                                brett.GetFelder()[vonFeld.GetPositionX() - counter, vonFeld.GetPositionY() + counter].GetSteinBesetzung() == null) //ist etwas im Weg?
                            {
                                if (zuFeld.GetPositionX() == vonFeld.GetPositionX() - counter &&                                                   //Stimmen zuFeldKoordinaten?
                                    zuFeld.GetPositionY() == vonFeld.GetPositionY() + counter)
                                {
                                    Debug.Log("Dame zieht");
                                    b = true;
                                    break;
                                }
                            }
                            else
                            {
                                Debug.Log("Stein im Weg");
                                break;
                            }
                        }
                        else if (zuFeld.GetPositionX() > vonFeld.GetPositionX() && zuFeld.GetPositionY() < vonFeld.GetPositionY())                           //ist Feld rechts unten?
                        {
                            Debug.Log("Feld ist rechts unten");
                            if (vonFeld.GetPositionX() + counter < brett.GetBreite() &&
                                vonFeld.GetPositionY() - counter >= 0 &&
                                brett.GetFelder()[vonFeld.GetPositionX() + counter, vonFeld.GetPositionY() - counter].GetSteinBesetzung() == null) //ist etwas im Weg?
                            {
                                if (zuFeld.GetPositionX() == vonFeld.GetPositionX() + counter &&                                                   //Stimmen zuFeldKoordinaten?
                                    zuFeld.GetPositionY() == vonFeld.GetPositionY() - counter)
                                {
                                    Debug.Log("Dame zieht");
                                    b = true;
                                    break;
                                }
                            }
                            else
                            {
                                Debug.Log("Stein im Weg");
                                break;
                            }
                        }
                    }
                }

                //NormalerStein Move:
                else if (s.GetFarbe() == Farbe.Weiß &&
                         vonFeld.GetSteinBesetzung().GetComponent <Stein>().GetFarbe() == Farbe.Weiß)                   //fuer weissen Stein
                {
                    if (zuFeld.GetSteinBesetzung() == null)
                    {
                        if (zuFeld.GetPositionX() == vonFeld.GetPositionX() - 1 && zuFeld.GetPositionY() == vonFeld.GetPositionY() + 1 || zuFeld.GetPositionX() == vonFeld.GetPositionX() + 1 && zuFeld.GetPositionY() == vonFeld.GetPositionY() + 1)                           // das Feld links oben oder rechts oben
                        {
                            //Debug.Log("Weiß zieht");
                            b = true;
                        }
                    }
                }
                else if (s.GetFarbe() == Farbe.Schwarz &&
                         vonFeld.GetSteinBesetzung().GetComponent <Stein>().GetFarbe() == Farbe.Schwarz)                     //fuer schwarzen Stein
                {
                    if (zuFeld.GetSteinBesetzung() == null)
                    {
                        if (zuFeld.GetPositionX() == vonFeld.GetPositionX() - 1 && zuFeld.GetPositionY() == vonFeld.GetPositionY() - 1 || zuFeld.GetPositionX() == vonFeld.GetPositionX() + 1 && zuFeld.GetPositionY() == vonFeld.GetPositionY() - 1)                           // das Feld links unten oder rechts unten
                        {
                            //Debug.Log("Schwarz zieht");
                            b = true;
                        }
                    }
                }
            }
            return(b);
        }