KrizciKrozciBot

/*
Yacked2, 9.1.2015
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace _3x3
{
    class Program
    {
        //doloca kdaj je igra neodlocena
        private static bool izenaceno = false;

        static void Main(string[] args)
        {
            bool zmaga = false;
            char[] polja = new char[9];

            //izbira kdo zacne
            Random rnd = new Random();
            int start = rnd.Next(0, 2);
            if (start == 0)
            {
                //zacne racunalnik
                while (!zmaga) //dokler nekdo ne zmaga
                {
                    polja = CPUPlay(polja); //potezo odigra racunalnik
                    zmaga = check(polja, 'C'); //preverimo ali je zmagal
                    izpis(polja); //izpisemo polje
                    if (zmaga == false)
                    {
                        //na potezi je uporabnik
                        polja = UserPlay(polja);
                        if (izenaceno)
                        {
                            Console.WriteLine("izenaceno!");
                            break;
                        }
                        //je uporabnik zmagal
                        zmaga = check(polja, 'U');
                        izpis(polja);
                        if (zmaga == true)
                        {
                            Console.WriteLine("Zmagali ste!");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Zmagal je racunalnik!");
                    }
                }
            }
            else
            {
                //zacne uporabnik
                izpis(polja); //zaceten izpis za uporabnika
                while (!zmaga)
                {
                    //izbira zacetnega polja
                    polja = UserPlay(polja);
                    zmaga = check(polja, 'U'); //preverimo ali smo zmagali
                    izpis(polja);
                    if (zmaga == false)
                    {
                        polja = CPUPlay(polja);
                        if (izenaceno)
                        {
                            Console.WriteLine("izenaceno!");
                            break;
                        }
                        zmaga = check(polja, 'C');
                        izpis(polja);
                        if (zmaga == true)
                        {
                            Console.WriteLine("Zmagal je racunalnik!");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Zmagali ste!");
                    }
                }
            }
            Console.ReadLine();
        }

        private static char[] CPUPlay(char[] polja)
        {
            //poiscemo prosta polja
            List<int> free = prosta(polja);
            if (free.Count == 0)
            {
                //ce so vsa polja zasedena, vrnemo - izenaceno
                izenaceno = true;
                return polja;
            }
            else if(free.Count == 9)
            {
                Random rnd = new Random();
                int choosen = rnd.Next(0, free.Count);
                polja[free[choosen]] = 'C';
                return polja;
            }
            ////////////////////////////////////////////////////////////////////////////////
            //OSNOVNI SISTEM
            ////////////////////////////////////////////////////////////////////////////////
            //ali lahko zmagamo
            for(int i=0; i < free.Count;i++)
            {
                char[] backup = new char[9];
                Array.Copy(polja, backup, 9);
                backup[free.ElementAt(i)] = 'C';
                bool preveri = check(backup,'C');
                if (preveri)
                {
                    backup[free.ElementAt(i)] = 'C';
                    return backup;
                }
            }

            //ali smo neposredno napadeni
            for (int i = 0; i < free.Count; i++)
            {
                char[] backup = new char[9];
                Array.Copy(polja, backup, 9);
                backup[free.ElementAt(i)] = 'U';
                bool preveri = check(backup, 'U');
                if (preveri)
                {
                    backup[free.ElementAt(i)] = 'C';
                    return backup;
                }
            }
            ////////////////////////////////////////////////////////////////////////////////
            //NAPREDNI SISTEM PREDVIDEVANJA
            ////////////////////////////////////////////////////////////////////////////////
            //izbira najboljsega nadaljevanja
            //shranjujemo koliko moznosti za zmago imamo v 2. koraku

            int[] stResitev = new int[free.Count];

            for (int i = 0; i < free.Count; i++)
            {
                int resitev = 0;

                //naredimo backup 1. nivoja
                char[] backup = new char[9];
                Array.Copy(polja, backup, 9);

                //ustavimo element na i-to mesto
                backup[free.ElementAt(i)] = 'C';

                //naredimo scan prostih mest v drugem koraku
                List<int> free_nivo2 = prosta(backup);

                //poiskusimo ustaviti na vsa možna mesta
                for (int j = 0; j < free_nivo2.Count; j++)
                {
                    //naredimo backup backupa :)
                    char[] backup2 = new char[9];
                    Array.Copy(backup, backup2, 9);

                    //ustavimo element na i-to mesto
                    backup2[free_nivo2.ElementAt(j)] = 'C';

                    bool preveri = check(backup2, 'C');
                    if (preveri)
                    {
                        //ce zmagamo v 2. koraku pristejemo moznost zmage
                        resitev++;
                    }
                }
                stResitev[i] = resitev;
            }

            //poiscemo najvecjo verjetnost zmage
            int index = 0; //na katerem indexu je največja številka
            for (int i = 1; i < free.Count; i++)
            {
                //iscemo najvecjo
                if (stResitev[i] > stResitev[index])
                {
                    index = i;
                }
            }

            ////////////////////////////////////////////////////////////////////////////////
            //ZMAGA V DRUGEM NIVOJU
            ////////////////////////////////////////////////////////////////////////////////
            //ce sta nato 2 mozna zakljucka smo ze zmagali
            if (stResitev[index] >= 2)
            {
                //zmaga v naslednem koraku
                polja[free[index]] = 'C';
                return polja;
            }
            else if (free.Contains(4)) //napad na sredo
            {
                //ce je mozno zasedimo sredino
                polja[4] = 'C';
                return polja;
            }


            ////////////////////////////////////////////////////////////////////////////////
            //PREVERI DIAGONALO
            ////////////////////////////////////////////////////////////////////////////////

            bool diagonala = false;
            int steviloZasedenihCPU = 0;
            int steviloZasedenihUSER = 0;
            //preverimo če smo mi v sredino in napad diagonalen
            for(int i=0; i < polja.Length; i++)
            {
                if(polja[i] == 'C')
                {
                    steviloZasedenihCPU++;
                }
                else if(polja[i] == 'U')
                {
                    steviloZasedenihUSER++;
                }
            }
            //ce smo CPU:1, USER:2
            if (steviloZasedenihCPU == 1 && steviloZasedenihUSER == 2)
            {
                //ali smo diagonalno
                if (polja[4] == 'C' && polja[0] == 'U' && polja[8] == 'U')
                {
                    diagonala = true;
                }
                else if (polja[4] == 'C' && polja[2] == 'U' && polja[6] == 'U')
                {
                    diagonala = true;
                }
            }

            //ce smo napadeno diagonalno se postavimo na rob, ce ne pa na kot
            if(diagonala)
            {
                //izberemo proste robove
                List<int> ProstiRobovi = new List<int>();

                for (int k = 0; k < free.Count; k++)
                {
                    if (free[k] == 1 || free[k] == 3 || free[k] == 5 || free[k] == 7)
                    {
                        ProstiRobovi.Add(free[k]); //polja prostih robov
                    }

                }
                //vsi robovi imajo enako verjetnost, zato izberemo nakjucnega

                Random rnd = new Random();
                int choosen = rnd.Next(0, ProstiRobovi.Count);
                polja[ProstiRobovi[choosen]] = 'C';

                return polja;
            }
            else //nismo diagonalno napadeni, poiscemo tiste z najvecjo verjetnostjo zmage, ce je mozno naj bo kot
            {
                //obstaja 2. hand napad ?

                ////////////////////////////////////////////////////////////////////////////////
                //OBRAMBA V DRUGEM NIVOJU
                ////////////////////////////////////////////////////////////////////////////////
                int[] USERstResitev = new int[free.Count];

                for (int i = 0; i < free.Count; i++)
                {
                    int USERresitev = 0;

                    //naredimo backup 1. nivoja
                    char[] USERbackup = new char[9];
                    Array.Copy(polja, USERbackup, 9);

                    //ustavimo element na i-to mesto
                    USERbackup[free.ElementAt(i)] = 'C';

                    //naredimo scan prostih mest v drugem koraku
                    List<int> USERfree_nivo2 = prosta(USERbackup);

                    //poiskusimo ustaviti na vsa možna mesta
                    for (int j = 0; j < USERfree_nivo2.Count; j++)
                    {
                        //naredimo backup backupa :)
                        char[] USERbackup2 = new char[9];
                        Array.Copy(USERbackup, USERbackup2, 9);

                        //ustavimo element na i-to mesto
                        USERbackup2[USERfree_nivo2.ElementAt(j)] = 'U';

                        bool preveri = check(USERbackup2, 'U');
                        if (preveri)
                        {
                            //ce zmagamo v 2. koraku pristejemo moznost zmage
                            USERresitev++;
                        }
                    }
                    USERstResitev[i] = USERresitev;
                }
                //poiscemo najvecjo verjetnost zmage
                int USERindex = 0; //na katerem indexu je največja številka
                for (int i = 1; i < free.Count; i++)
                {
                    //iscemo najvecjo
                    if (USERstResitev[i] > USERstResitev[USERindex])
                    {
                        USERindex = i;
                    }
                }
                if (USERstResitev[USERindex] >= 2)
                {
                    //zmaga v naslednem koraku
                    polja[free[USERindex]] = 'C';
                    return polja;
                }

                //nadaljevanje po kotih
                List<int> ugodna = new List<int>();
                for (int k = 0; k < free.Count; k++)
                {
                    if (stResitev[k] == stResitev[index])
                    {
                        ugodna.Add(free[k]);
                    }

                }
                List<int> ZanesliviKoti = new List<int>();
                //je med ugodnimi mogoče kot ?
                if(ugodna.Contains(0) || ugodna.Contains(2) || ugodna.Contains(6) || ugodna.Contains(8))
                {
                    //izberemo kot :)
                    if(ugodna.Contains(0))
                    {
                        ZanesliviKoti.Add(0);
                    }
                    if(ugodna.Contains(2))
                    {
                        ZanesliviKoti.Add(2);
                    }
                    if(ugodna.Contains(6))
                    {
                        ZanesliviKoti.Add(6);
                    }
                    if(ugodna.Contains(8))
                    {
                        ZanesliviKoti.Add(8);
                    }
                    //izberemo enega izmed nakljucnih
                    Random rnd = new Random();
                    int choosen = rnd.Next(0, ZanesliviKoti.Count);
                    polja[ZanesliviKoti[choosen]] = 'C';
                    return polja;

                }
                else //izberemo nakjucnega
                {
                    Random rnd = new Random();
                    int choosen = rnd.Next(0, ugodna.Count);
                    polja[ugodna[choosen]] = 'C';
                    return polja;
                }
            }

        }

        private static char[] UserPlay(char[] polja)
        {
            //poiscemo prazne prostore
            List<int> free = new List<int>();
            for (int i = 0; i < polja.Length; i++)
            {
                if (polja[i] == default(char))
                {
                    free.Add(i);
                }
            }

            if (free.Count == 0)
            {
                //izenačeno
                izenaceno = true;
                return polja;
            }

            //uporabnikov vnos
            Console.WriteLine(string.Join(",",free));
            while(true)
            {
                int a = Int32.Parse(Console.ReadLine());
                if (free.Contains(a))
                {
                    polja[a] = 'U';
                    break;
                }
            }
            return polja;
        }

        private static bool check(char[] polja, char igralec)
        {
            //preverimo ali je igralec zmagal, ima kaksno 3 v vrsto.
            if (polja[0] == igralec && polja[1] == igralec && polja[2] == igralec)
            {
                return true;
            }
            if (polja[3] == igralec && polja[4] == igralec && polja[5] == igralec)
            {
                return true;
            }
            if (polja[6] == igralec && polja[7] == igralec && polja[8] == igralec)
            {
                return true;
            }
            if (polja[0] == igralec && polja[3] == igralec && polja[6] == igralec)
            {
                return true;
            }
            if (polja[1] == igralec && polja[4] == igralec && polja[7] == igralec)
            {
                return true;
            }
            if (polja[2] == igralec && polja[5] == igralec && polja[8] == igralec)
            {
                return true;
            }
            if (polja[0] == igralec && polja[4] == igralec && polja[8] == igralec)
            {
                return true;
            }
            if (polja[2] == igralec && polja[4] == igralec && polja[6] == igralec)
            {
                return true;
            }
            //če ni igramo naprej
            return false;
        }

        private static List<int> prosta(char[] polja)
        {
            //preverimo katera polja so prosta in jih vrnemo
            List<int> free = new List<int>();
            for (int i = 0; i < polja.Length; i++)
            {
                if (polja[i] == default(char) && (polja[i] != 'U' || polja[i] != 'C'))
                {
                    free.Add(i);

                }
            }
            return free;
        }

        private static  void izpis(char[] polja)
        {
            //izpisemo trenutno stanje na polju
            char[] backup = new char[9];
            Array.Copy(polja, backup, 9);

            for (int i = 0; i < backup.Length; i++)
            {
                if (backup[i] == default(char))
                {
                    backup[i] = 'X';
                }
            }
            for (int i = 1; i <= backup.Length; i++)
            {
                if (i % 3 == 0)
                {
                    Console.Write(backup[i - 1]);
                    Console.WriteLine();
                }
                else
                {
                    Console.Write(backup[i - 1]);
                }
            }
            Console.WriteLine();
        }
    }
}