memory

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

namespace MemoryGame
{
    enum Color { Rosso, Verde, Giallo, Blu, Viola, Bianco, Marrone, Celeste, Arancione,VerdeOliva, RosaScuro,Oro,last }

    class Program
    {
        struct CardColor
        {
            public byte R;
            public byte G;
            public byte B;
        }
        struct Card
        {
            public int X;
            public int Y;
            public int Width;
            public int Height;
            public int LeftPadding;
            public int UpPadding;
            public CardColor color;
        }
        static void Main(string[] args)
        {
            int row;
            int col;
            int leftPadding = 20;
            int upPadding = 20;
            int cardWidth = 70;
            int cardHeight = 100;
            int windowWidth = 1000;
            int windowHeight = 1000;
            int maxRow = (windowWidth / (cardHeight + upPadding));
            int maxCol = (windowHeight / (cardWidth + leftPadding));
            Console.WriteLine("Righe massime: " + maxRow);
            Console.WriteLine("Colonne massime: "+ maxCol);

            AskRowCol(out row, out col,maxRow,maxCol);
            Window window = new Window(windowWidth, windowHeight, "Memory", PixelFormat.RGB);
            Card[] deck = new Card[row * col];
            CardColor[] color = new CardColor[(int)Color.last];
            for (int i = 0; i < (int)Color.last; i++)
            {
                CreateColor(color, (Color)i);
            }
            CreateDeck(window, deck, leftPadding, upPadding,col,row,cardWidth,cardHeight,color);
            Card[] coveredDeck = new Card[deck.Length+2];
            CopyDeck(coveredDeck, deck);
            CardColor cover;
            InitCover(out cover);
            CoverDeck(coveredDeck, cover);
            int mouseX1=-1;
            int mouseY1=-1;
            bool firstClick = true;

            int index1=-1;
            int saveindex1 = -1;
            int saveindex2 = -1;
            int uncoverCards=0;
            int cardSelected = 0;
            float resetTime = 80;
            int[] uncoverIndex = new int[deck.Length+2];
            bool swap = true;
            float time = 0;
            bool reset = false;
            bool fine = false;

            while(window.opened)
            {
                Clear(window);
                DrawDeck(window, coveredDeck);
                SelectTwoCards(window, deck, coveredDeck, ref mouseX1, ref mouseY1, ref firstClick, ref index1, ref saveindex1, ref saveindex2, ref cardSelected, ref swap);
                if(CompareCard(window, deck, saveindex1, saveindex2, uncoverIndex, ref uncoverCards)&&cardSelected==2)
                {
                    swap = true;
                    cardSelected = 0;
                    saveindex1 = -1;
                    saveindex2 = -1;
                    index1 = -1;
                }
                else if(cardSelected>=2)
                {
                    swap = true;
                    reset = true;
                    Reset(coveredDeck, cover, ref index1, ref saveindex1, ref saveindex2, ref cardSelected, ref time, ref reset);
                }
                WaitTime(resetTime, window, reset, ref time);
                if(uncoverCards>=deck.Length)
                {
                    DrawDeck(window, deck);
                    if (fine)
                    {
                    Console.WriteLine("Hai vinto");
                    break;
                    }
                    fine = true;
                }
                window.Blit();
            }
            Console.ReadLine();
        }

        static void Reset(Card[] coveredDeck, CardColor cover, ref int index1, ref int saveindex1, ref int saveindex2, ref int cardSelected, ref float time, ref bool reset)
        {
            if (time >= 100 && saveindex1 >= 0 && saveindex2 >= 0)
            {
                coveredDeck[saveindex1].color = cover;
                coveredDeck[saveindex2].color = cover;
                cardSelected = 0;
                saveindex1 = -1;
                saveindex2 = -2;
                index1 = -3;
                time = 0;
                reset = false;
            }
        }

        static void SelectTwoCards(Window window, Card[] deck, Card[] coveredDeck, ref int mouseX1, ref int mouseY1, ref bool firstClick, ref int index1, ref int saveindex1, ref int saveindex2, ref int uncoverCards, ref bool swap)
        {
            if (uncoverCards < 2)
            {
                if (UncoverFirstCard(window, ref mouseX1, ref mouseY1, ref firstClick, ref index1, deck, ref uncoverCards))
                {
                    if (swap)
                    {
                        saveindex1 = index1;
                        swap = false;
                        coveredDeck[saveindex1].color = deck[saveindex1].color;
                    }
                    else
                    {
                        saveindex2 = index1;
                        coveredDeck[saveindex2].color = deck[saveindex2].color;
                    }
                }
            }
        }

        static bool UncoverFirstCard(Window window,ref int mouseX1, ref int mouseY1,ref bool firstClick,ref int index1,Card[] deck, ref int uncoverCards)
        {

            if(Click(window, ref mouseX1, ref mouseY1, ref firstClick))
            {
                if (CheckClick(ref index1, mouseX1, mouseY1, deck))
                {
                    uncoverCards++;
                    return true;
                }
            }
            return false;
        }

        static void DrawUncoverCard(Window window, int[] uncoverIndex, int uncoverCard,Card[] deck)
        {
            for (int i = 0; i < uncoverCard; i++)
            {
                DrawRect(window, deck[i]);
            }
        }

        static bool CompareCard(Window window, Card[] deck,int index1,int index2, int[] uncoverIndex,ref int uncoverCards)
        {
            if (CompareColor(deck, index1, index2))
            {
                uncoverCards += 2;
                uncoverIndex[uncoverCards] = index1;
                uncoverIndex[uncoverCards + 1] = index2;
                return true;
            }
            else
            {
                return false;
            }
        }

        static void WaitTime(float resetTime,Window window,bool reset, ref float time)
        {
            if (reset)
            {
                time += resetTime * window.deltaTime;
            }
        }

        static bool CompareColor(Card[] deck, int index1, int index2)
        {
            if (index1 >= 0 && index2>=0)
            {
                if ((deck[index1].color.R == deck[index2].color.R) && (deck[index1].color.G == deck[index2].color.G) && (deck[index1].color.B == deck[index2].color.B))
                {
                    return true;
                }
            }

            return false;
        }

        static bool CheckClick(ref int index, int mouseX, int mouseY, Card[] deck)
        {
            for (int i = 0; i < deck.Length; i++)
            {
                if ((mouseX >= deck[i].X && mouseX <= deck[i].X + deck[i].Width) && (mouseY >= deck[i].Y && mouseY <= deck[i].Y + deck[i].Height))
                {
                    index = i;
                    return true;
                }
            }
            return false;
        }

        static bool Click(Window window, ref int mouseX, ref int mouseY,ref bool firstClick)
        {
            if (window.mouseLeft && firstClick)
            {
                mouseX = window.mouseX;
                mouseY = window.mouseY;
                firstClick = false;
                return true;
            }
            else
            {
                if(!window.mouseLeft) firstClick = true;
                return false;
            }
        }

        static void CopyDeck(Card[] coveredDeck, Card[] deck)
        {
            for (int i = 0; i < deck.Length; i++)
            {
                coveredDeck[i] = deck[i];
            }
        }

        static void InitCover(out CardColor cover)
        {
            cover.R = 128;
            cover.G = 128;
            cover.B = 128;
        }

        static void CoverDeck(Card[] coveredDeck, CardColor color)
        {
            for (int i = 0; i < coveredDeck.Length; i++)
            {
                coveredDeck[i].color = color;
            }
        }

        static void CreateColor(CardColor[] color, Color enumColor)
        {
            switch (enumColor)
            {
                case Color.Rosso:
                    color[(int)enumColor].R = 255;
                    color[(int)enumColor].G = 0;
                    color[(int)enumColor].B = 0;
                    break;
                case Color.Verde:
                    color[(int)enumColor].R = 0;
                    color[(int)enumColor].G = 255;
                    color[(int)enumColor].B = 0;
                    break;
                case Color.Giallo:
                    color[(int)enumColor].R = 255;
                    color[(int)enumColor].G = 255;
                    color[(int)enumColor].B = 102;
                    break;
                case Color.Blu:
                    color[(int)enumColor].R = 0;
                    color[(int)enumColor].G = 0;
                    color[(int)enumColor].B = 255;

                    break;
                case Color.Viola:
                    color[(int)enumColor].R = 128;
                    color[(int)enumColor].G = 0;
                    color[(int)enumColor].B = 128;
                    break;
                case Color.Bianco:
                    color[(int)enumColor].R = 255;
                    color[(int)enumColor].G = 255;
                    color[(int)enumColor].B = 255;
                    break;
                case Color.Marrone:
                    color[(int)enumColor].R = 101;
                    color[(int)enumColor].G = 67;
                    color[(int)enumColor].B = 33;
                    break;
                case Color.Celeste:
                    color[(int)enumColor].R = 10;
                    color[(int)enumColor].G = 186;
                    color[(int)enumColor].B = 181;
                    break;
                case Color.Arancione:
                    color[(int)enumColor].R = 255;
                    color[(int)enumColor].G = 117;
                    color[(int)enumColor].B = 20;
                    break;
                case Color.VerdeOliva:
                    color[(int)enumColor].R = 128;
                    color[(int)enumColor].G = 128;
                    color[(int)enumColor].B = 0;
                    break;
                case Color.RosaScuro:
                    color[(int)enumColor].R = 231;
                    color[(int)enumColor].G = 84;
                    color[(int)enumColor].B = 128;
                    break;
                case Color.Oro:
                    color[(int)enumColor].R = 255;
                    color[(int)enumColor].G = 215;
                    color[(int)enumColor].B = 0;
                    break;
                default:
                    break;
            }
        }

        static void DrawDeck(Window window, Card[] deck)
        {
            for (int i = 0; i < deck.Length; i++)
            {
                DrawRect(window, deck[i]);
            }
        }
        static void CreateDeck(Window window, Card[] deck, int leftPadding, int upPadding,int col, int row,int width, int height, CardColor[] color)
        {
            Random r = new Random();
            int cardWidth = width;
            int cardHeight = height;
            int tempX = 0;
            int tempY = 0 - deck[0].Height;
            InitCard(tempX,tempY, deck, leftPadding, upPadding,cardWidth, cardHeight, color);
            PlaceCard(window, deck, col, row, ref tempX, ref tempY);
            ShuffleCard(deck, r);
        }

        static void ShuffleCard(Card[] deck, Random r)
        {
            Card card;
            for (int i = 0; i < deck.Length; i++)
            {
                int index = r.Next(0, deck.Length);
                card = deck[i];
                deck[i].color = deck[index].color;
                deck[index].color = card.color;
            }
        }

        static void PlaceCard (Window window, Card[] deck,int col, int row, ref int tempX, ref int tempY)
        {
            bool firstCard = true;

            int rowCount = 0;
            for (int i = 0; i < deck.Length; i++)
            {
                if (rowCount==0)
                {
                    tempX = 0;
                    deck[i].X = deck[i].LeftPadding;
                    tempX = deck[i].X;
                    if (firstCard)
                    {
                        deck[i].Y = deck[i].UpPadding;
                        firstCard = false;
                    }
                    else
                    {
                        deck[i].Y += tempY + deck[i].UpPadding+deck[i].Height;
                    }
                    tempY = deck[i].Y;
                    rowCount = col;
                }
                else
                {
                    deck[i].X = tempX + deck[i].LeftPadding + deck[i].Width;
                    deck[i].Y = tempY;
                    tempX = deck[i].X;
                }
                    rowCount--;
            }

        }

        static void DrawRect(Window window, Card card)
        {
            for (int i = card.Y; i <card.Y + card.Height; i++)
            {
                DrawHorizontalLine(window, card.X, i, card.Width, card.color);
            }
        }
        static void Clear(Window window)
        {
            for (int i = 0; i < window.bitmap.Length; i++)
            {
                window.bitmap[i] = 0;
            }
        }

        static void InitCard(int newX, int newY, Card[] card, int leftPadding, int upPadding,int width, int height, CardColor[] color)
        {
            int c = 0;
            for (int i = 0; i < card.Length; i++)
            {
                card[i].Width = width;
                card[i].Height = height;
                card[i].UpPadding = upPadding;
                card[i].LeftPadding = leftPadding;
                card[i].X = newX;
                card[i].Y = newY;
            }
            for (int i = 0; i < card.Length; i+=2)
            {
                if (c>=color.Length)
                {
                    c = 0;
                }
                byte col = color[c].R;
                card[i].color.R = col;
                card[i].color.G = color[c].G;
                card[i].color.B = color[c].B;
                card[i + 1].color.R = color[c].R;
                card[i + 1].color.G = color[c].G;
                card[i + 1].color.B = color[c].B;
                c++;
            }
        }

        static void DrawHorizontalLine(Window win, int x, int y, int width, CardColor color)
        {
            for (int i = x; i < x + width; i++)
            {
                PutPixel(win, i, y, color);
            }
        }
        static void PutPixel(Window win, int x, int y, CardColor color)
        {
            if (x >= 0 && y >= 0 && x < win.width && y < win.height)
            {
                int index = (y * win.width + x) * 3;

                win.bitmap[index] = color.R;
                win.bitmap[index + 1] = color.G;
                win.bitmap[index + 2] = color.B;
            }
        }

        static void AskRowCol(out int row, out int col,int maxRow, int maxCol)
        {
            row = 1;
            col = 1;
            bool check = false;
            bool checkCol = false;
            bool checkRow = false;
            while (!check)
            {
                Console.Write("Quante righe vuoi?: ");
                row = int.Parse(Console.ReadLine());
                Console.Write("Quante colonne vuoi?: ");
                col = int.Parse(Console.ReadLine());
                if (row<=maxRow)
                {
                    checkRow = true;
                }
                if (col<=maxCol)
                {
                    checkCol = true;
                }
                if (col % 2 == 0 && checkRow && checkCol)
                {
                    check = true;
                }
                else check = false;

            }
        }
    }
}