memo2

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 float Width;
            public int Height;
            public int LeftPadding;
            public int UpPadding;
            public CardColor color;
            public CardColor cover1;
            public CardColor cover2;
        }
        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);
            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 = 50;
            bool reset = false;
            bool fine = false;
            float uncoverSpeed = 250;
            int coverTime = 0;
            bool completed = false;
            bool uncover=false;
            bool uncover2 = false;
            bool waitAnimation = false;
            bool swapColor = false;

            while (window.opened)
            {
                Clear(window);
                DrawCoverDeck(window, coveredDeck);
                SelectTwoCards(window, deck, coveredDeck, ref mouseX1, ref mouseY1, ref firstClick, ref index1, ref saveindex1, ref saveindex2, ref cardSelected, ref swap, completed, ref uncover, ref uncover2, ref waitAnimation,ref cardWidth, uncoverSpeed, ref uncover2);
                Animation(cardWidth, window, coveredDeck, saveindex1, uncoverSpeed, ref swapColor, ref uncover, ref uncover2,ref completed);

                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, deck, 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;
                }

                Console.WriteLine(coveredDeck[1].Width);
                window.Blit();
            }
            Console.ReadLine();
        }

        private static void Animation(int cardWidth, Window window, Card[] coveredDeck, int saveindex1, float uncoverSpeed, ref bool swapColor, ref bool uncover, ref bool uncover2, ref bool completed)
        {
            if (uncover && saveindex1 >= 0)
            {
                coveredDeck[saveindex1].Width -= uncoverSpeed * window.deltaTime;
                if (coveredDeck[saveindex1].Width <= 0)
                {
                    swapColor = true;
                    uncover = false;
                    uncover2 = true;
                }

            }
            if (uncover2)
            {
                Console.WriteLine(saveindex1);
                coveredDeck[saveindex1].Width += uncoverSpeed * window.deltaTime;
                if (coveredDeck[saveindex1].Width >= cardWidth)
                {
                    swapColor = false;
                    uncover2 = false;
                    completed = true;
                }
            }
        }

        static void DrawCoverDeck(Window window, Card[] deck)
        {
            for (int i = 0; i < deck.Length; i++)
            {
                DrawCoverRect(window, deck[i]);
            }
        }

        static void DrawCoverRect(Window window, Card card)
        {
            bool swap = true;
            int c = 0;
            for (int i = card.Y; i < card.Y + card.Height; i++)
            {
                if (swap)
                {
                    DrawHorizontalLine(window, card.X, i, (int)card.Width,card.cover1);
                }
                else
                {
                    DrawHorizontalLine(window, card.X, i, (int)card.Width, card.cover2);

                }
                c++;
                if (c>=6)
                {
                    c = 0;
                    swap = !swap;
                }
            }
        }

        static void Reset(Card[] coveredDeck,Card[] deck, 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].cover1 = deck[saveindex2].cover1;
                coveredDeck[saveindex1].cover2 = deck[saveindex1].cover2;
                coveredDeck[saveindex2].cover1 = deck[saveindex2].cover1;
                coveredDeck[saveindex2].cover2 = deck[saveindex2].cover2;
                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,bool swapColor,ref bool uncover, ref bool coverAnimation, ref bool waitAnimation,
            ref int cardWidth, float uncoverSpeed, ref bool uncover2)
        {
            bool completed = false;
            if (uncoverCards < 2)
            {
                if (UncoverFirstCard(window, ref mouseX1, ref mouseY1, ref firstClick, ref index1, deck, ref uncoverCards)|| waitAnimation)
                {
                    waitAnimation = true;
                    if (swap)
                    {
                        uncover = true;
                        saveindex1 = index1;

                        if (swapColor)
                        {
                            coveredDeck[saveindex1].cover1 = deck[saveindex1].color;
                            coveredDeck[saveindex1].cover2 = deck[saveindex1].color;
                        }
                        if(completed)
                        {

                            swap = false;
                            waitAnimation = false;
                        }



                    }
                    else
                    {
                        uncover = true;
                        saveindex2 = index1;
                        //Animation(cardWidth, window, coveredDeck, saveindex2, uncoverSpeed, ref completed, ref uncover, ref uncover2);

                        if (swapColor)
                        {
                            coveredDeck[saveindex2].cover1 = deck[saveindex2].color;
                            coveredDeck[saveindex2].cover2 = 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 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 + (int)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, (int)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;
                card[i].cover1 = color[(int)Color.Bianco];
                card[i].cover2 = color[(int)Color.Rosso];
            }
            for (int i = 0; i < card.Length; i += 2)
            {
                if (c >= color.Length)
                {
                    c = 0;
                }
                card[i].color = color[c];
                card[i + 1].color = color[c];
                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;

            }
        }
    }
}