source: 2010/24/ramipasa/ALTKTileEngine/Peli.cs @ 960

using System;                        // Tämän tarpeellisuus pitäisi olla itsestäänselvyys
using Jypeli;                        // Jypeli
using Jypeli.ScreenObjects;          // Jypeli.ScreenObjects
using Jypeli.Assets;                 // Jypeli.Assets
using System.Collections.Generic;    // Jypelin tutoriaali
using System.IO;                     // Streamreader vaatii tämän
using System.Windows.Forms;          // jotta voin näyttää msgboxeja
using ALTKTechs;                     // Avaruuslaatikon moottorikomponentit
using ALTKUnits;
using ALTKCiv;
using ALTKPromotions;
using ALTKDiff;
using ALTKAIBehaviour;
using BaseRules;                     // Avaruuslaatikon sääntötiedosto, helpottaa modien tekemistä
using System.Threading;              // voin käyttää Thread.Sleepiä

namespace ALTKTileEngine
{
    public class Peli : Game
    {
        bool gamestarted = false;
        int currDiffLevel; // jotta tätä voidaan käyttää missä tahansa

        int[,] TerrainMap; // perusmaastokartta
        int[,] DTerrainMap; // erikoismaastokartta
        int[,] OwnershipMap; // ruudukon omistuskartta (kenen pelaajan hallinnassa on mikäkin ruutu)
        int[,] ShroudMap; // pelaajan näkymää pienentävä Shroudmap
        int[,] UnitMap; // yksikkökartta

        string Textpath;
        string OwnershipColorPath;

        int AmountofPlayers; // Ihmispelaajien määrä, tällä hetkellä peli tukee vain yhtä
        int TurnNumber; // vuoron numero
        int CurrProduction; // pelaajan tämänhetkinen tuotanto

        // !!!!!!!!!!!!!!!!!!!!!!!!!!!
        // Pitänee tehdä vielä yksi ALTKSUnit-namespace ALTKCoreen.
        // Tämä sisältäisi tiedot yksiköiden omistajasta, yksikön perusyksiköstä ym. sekä myös karttakoordinaatit
        // (karttakoordinaatit säilyttää myös UnitMap, josta on helppo tarkastaa esim. liikuttaessa yksiköitä, onko ruudussa jo esim. vihollisyksiköitä.

        int SelectedUnit = -1;

        bool UnitsSelected = new bool();

        TextDisplay TileDisp;
        TextDisplay UnitStatsDisp;
        TextDisplay ProductionDisp;
        TextDisplay BuildCityDisp;
        TextDisplay BuildUnitsDisp;
        TextDisplay Unit1Disp;
        TextDisplay Unit2Disp;
        TextDisplay Unit3Disp;
        TextDisplay Unit4Disp;
        TextDisplay ResearchDisp;
        TextDisplay ResearchableTech1;
        TextDisplay ResearchableTech2;
        TextDisplay ResearchableTech3;
        TextDisplay ClicktoResearch;

        int kartanLeveys;
        int kartanKorkeus;

        int CurrentPlayer;

        bool CityPlaceSelection;
        bool TileClickAllowed = false;

        bool UnitBuildingMode = false;
        bool UnitPositioningMode = false;
        int currentunit = new int();

        // perusmaastotyypit
        const int Aavikko = 2, Tundra = 3, Vuoristo = 1, Lehtimetsa = 0;

        // erikoismaastotyypit
        const int Havumetsa = 2, Tyhja = 0, Kuusimetsa = 3;

        // Pelissä on viisi eri tasoa, toisella perusmaasto ja toisella tarkempaa tietoa (esim. onko ruutu metsää ym.)
        // Kolmas taso kertoo, kenen valtion hallinnassa ruutu on, neljäs on Fog of War, ja viides piirtää yksiköt.
        GameObject[,] tile;
        GameObject[,] DTile;
        GameObject[,] TileOwnership;
        GameObject[,] ShroudTile;
        GameObject[,] UnitTile;
        //Vector tileVector;

        Vector CamSpeedEast = new Vector(20.0, .0);
        Vector CamSpeedWest = new Vector(-20.0, .0);
        Vector CamSpeedNorth = new Vector(.0, 20.0);
        Vector CamSpeedSouth = new Vector(.0, -20.0);

        // Käytän ennemmin enemmän muistia kuin prosessoria, joten lasken nämä jo täällä
        int MouseScreenWidth;
        int MouseScreenHeight;
        int NegMouseScreenWidth;
        int NegMouseScreenHeight;
        # region Aloitusruutuvalikko
        protected override void Begin()
        {
            //SetWindowSize(true);
            Textpath = Application.StartupPath + "\\Content\\Textures\\";
            OwnershipColorPath = Textpath + "Ownership\\";
            InitRules();
            InitStartMenu();
            //InitControls();
            //InitMap();
        }
        void InitStartMenu()
        {
            Level.BackgroundColor = Color.Gray;
            Mouse.Enabled = true;
            Mouse.IsCursorVisible = true;

            InputQueryWindow input = new InputQueryWindow();
            input.InputConfirmed += Player_SetName;
            input.QueryText.Text = "Kirjoita valtiosi nimi:";
            input.Size = new Vector(300.0, 100.0);
            input.Position = new Vector(-250.0, 350.0);
            input.InputBox.BorderColor = Color.GreenYellow;
            ShowWindow(input);

            GameObject TrainingButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject EasyButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject NormalButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject HardButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject VHardButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject NightmareButton = new GameObject(250, 30, Shapes.Rectangle);
            GameObject InsanityButton = new GameObject(250, 30, Shapes.Rectangle);

            for (int a = 0; a <= 6; a++)
            {
                if (a == 0) { SetDiffButton(TrainingButton, 0); }
                if (a == 1) { SetDiffButton(EasyButton, 1); }
                if (a == 2) { SetDiffButton(NormalButton, 2); }
                if (a == 3) { SetDiffButton(HardButton, 3); }
                if (a == 4) { SetDiffButton(VHardButton, 4); }
                if (a == 5) { SetDiffButton(NightmareButton, 5); }
                if (a == 6) { SetDiffButton(InsanityButton, 6); }
            }
            Mouse.ListenOn(TrainingButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 0);
            Mouse.ListenOn(EasyButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 1);
            Mouse.ListenOn(NormalButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 2);
            Mouse.ListenOn(HardButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 3);
            Mouse.ListenOn(VHardButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 4);
            Mouse.ListenOn(NightmareButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 5);
            Mouse.ListenOn(InsanityButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 6);
        }

        void Player_SetName(InputQueryWindow sender, string input)
        {
            Rules.pCivs[0].Name = input;
            Rules.pCivs[0].HumanPlayer = true;
            Rules.pCivs[0].Enabled = true;
            Rules.pCivs[0].Color = "red";
        }

        void SetDiffButton(GameObject diffbutton, int difflevel)
        {
            diffbutton.X = 250;
            diffbutton.Y = ((difflevel * -50) + 300);
            if (difflevel == 0) { diffbutton.Image = LoadImage(Textpath + "training"); }
            else if (difflevel == 1) { diffbutton.Image = LoadImage(Textpath + "easy"); }
            else if (difflevel == 2) { diffbutton.Image = LoadImage(Textpath + "normal"); }
            else if (difflevel == 3) { diffbutton.Image = LoadImage(Textpath + "hard"); }
            else if (difflevel == 4) { diffbutton.Image = LoadImage(Textpath + "vhard"); }
            else if (difflevel == 5) { diffbutton.Image = LoadImage(Textpath + "nightmare"); }
            else if (difflevel == 6) { diffbutton.Image = LoadImage(Textpath + "insanity"); }
            Add(diffbutton);
            //return diffbutton;
        }

        void SelectDifficulty(int difflevel)
        {
            ClearAll();
            currDiffLevel = new int();
            currDiffLevel = difflevel;
            InitControls();
            InitMap();
            gamestarted = true;
        }
        # endregion
        # region Kartan luominen

        void InitMap()
        {
            TurnNumber = new int();
            AmountofPlayers = new int();
            Int32 i;
            Int32 j;
            string mLine;
            TextReader bReader;
            bReader = new StreamReader("Content\\Maps\\1\\base.txt");
            //try
            //{

            // Yleensä kartan kaksi ensimmäistä riviä ovat kommentteja
            bReader.ReadLine();
            bReader.ReadLine();

            kartanLeveys = Convert.ToInt32(bReader.ReadLine().Substring(9, 2));
            kartanKorkeus = Convert.ToInt32(bReader.ReadLine().Substring(10, 2));

            Int32 mapWidthJ = (kartanLeveys * 48) / 2;
            Int32 mapHeightJ = (kartanKorkeus * 48) / 2;

            bReader.ReadLine();
            // Ladataan TerrainMapit muistiin myöhempää käyttöä varten

            TerrainMap = new int[kartanKorkeus, kartanLeveys];
            DTerrainMap = new int[kartanKorkeus, kartanLeveys];
            OwnershipMap = new int[kartanKorkeus, kartanLeveys];
            ShroudMap = new int[kartanKorkeus, kartanLeveys];
            UnitMap = new int[kartanKorkeus, kartanLeveys];
            InitTerrain(0);
            InitTerrain(1);
            InitTerrain(2);
            InitTerrain(3);
            InitTerrain(4);

            tile = new GameObject[kartanKorkeus, kartanLeveys];
            DTile = new GameObject[kartanKorkeus, kartanLeveys];
            TileOwnership = new GameObject[kartanKorkeus, kartanLeveys];
            ShroudTile = new GameObject[kartanKorkeus, kartanLeveys];
            UnitTile = new GameObject[kartanKorkeus, kartanLeveys];
            InitTerrainGraphics(0);
            InitTerrainGraphics(1);
            InitTerrainGraphics(2);
            InitTerrainGraphics(3);
            InitTerrainGraphics(4);

            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    UnitMap[i, j] = -1;
                }
            }

            // Initialisoidaan Unitmap

            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    UnitTile[i, j].Shape = Shapes.Rectangle;
                    UnitTile[i, j].X = (j * 48) - mapWidthJ;
                    UnitTile[i, j].Y = (i * 48) - mapHeightJ;
                    UnitTile[i, j].Image = LoadImage(Textpath + "nothing");
                    Add(UnitTile[i, j]);
                }
            }

            // Koodi käännetty RGE:n VB.netistä
            // Asettaa ja piirtää pohjamaaston

            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                mLine = bReader.ReadLine();
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    // MessageBox.Show(mLine + " " + j + " " + i);s
                    tile[i, j].Shape = Shapes.Rectangle;
                    tile[i, j].X = (j * 48) - mapWidthJ;
                    tile[i, j].Y = (i * 48) - mapHeightJ;
                    TerrainMap[i, j] = getTerrainType(mLine.Substring(j, 1), 0, i, j);
                    tile[i, j].Image = LoadImage(getTexture_fromTerrainType(TerrainMap[i, j], 0, i, j));
                    Add(tile[i, j]);
                    Mouse.ListenOn(tile[i, j], MouseButton.Left, Jypeli.ButtonState.Released, TileClicked, "", i, j);
                    //Mouse.ListenMovement(tile[i, j], showTileInfo_forTileDisp, null, i, j);
                    // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
                }
            }

            // Luetaan karttatiedoston rivivälit
            bReader.ReadLine();
            bReader.ReadLine();

            // Rami 16. 6. 2010: Omistuskartta pitää sittenkin säätää ennen erikoismaastoa, sillä
            // kaupungit ja omistusrinki piirretään erikoismaaston asettamiskoodin kutsusta
            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    // MessageBox.Show(mLine + " " + j + " " + i);
                    OwnershipMap[i, j] = -1;
                    TileOwnership[i, j].Shape = Shapes.Rectangle;
                    TileOwnership[i, j].X = (j * 48) - mapWidthJ;
                    TileOwnership[i, j].Y = (i * 48) - mapHeightJ;
                    TileOwnership[i, j].Image = LoadImage(Textpath + "nothing");
                    Add(TileOwnership[i, j]);
                    //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
                    // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
                }
            }

            // Initialisoidaan Shroudmap

            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    ShroudMap[i, j] = 1;
                    ShroudTile[i, j].Shape = Shapes.Rectangle;
                    ShroudTile[i, j].X = (j * 48) - mapWidthJ;
                    ShroudTile[i, j].Y = (i * 48) - mapHeightJ;
                    ShroudTile[i, j].Image = LoadImage(Textpath + "fogofwar");
                }
            }


            // Asettaa ja piirtää erikoismaaston

            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                mLine = bReader.ReadLine();
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    DTile[i, j].Shape = Shapes.Rectangle;
                    DTile[i, j].X = (j * 48) - mapWidthJ;
                    DTile[i, j].Y = (i * 48) - mapHeightJ;
                    DTerrainMap[i, j] = getTerrainType(mLine.Substring(j, 1), 1, i, j);
                    DTile[i, j].Image = LoadImage(getTexture_fromTerrainType(DTerrainMap[i, j], 1, i, j));
                    Add(DTile[i, j]);
                    if (getTexture_fromTerrainType(DTerrainMap[i, j], 1, i, j).Contains("city"))
                    {
                        DrawOwnership(i, j);
                    }
                }
            }

            // Piirretään ShroudTile vasta tässä, jotta se olisi DTilen päällä
            for (i = 0; i <= (kartanKorkeus - 1); i++)
            {
                for (j = 0; j <= (kartanLeveys - 1); j++)
                {
                    if (ShroudMap[i, j] == 1)
                    {
                       Add(ShroudTile[i, j]);
                    }
                }
            }

            //catch
            //{
            //    MessageBox.Show("Map error!");
            //    bReader.Close();
            //    Exit();
            //}
            bReader.Close();
            //for (int playernumber = 0; playernumber <= 30; playernumber++)
            //{
            //    Rules.pCivs[playernumber].Color = setAIOwnershipColor(playernumber);
            //}
            Level.BackgroundColor = Color.Black;
            InitGUI();

            Application.DoEvents();
            TurnSystem_Start(0); // Antaa pelin alkaa!
        }

        private void InitTerrain(int tlayer)
        {
            for (int a = 0; a <= (kartanKorkeus - 1); a++)
            {
                for (int b = 0; b <= (kartanLeveys - 1); b++)
                {
                    GetTerrainLayer(tlayer)[a, b] = new int();
                }
            }
        }

        int[,] GetTerrainLayer(int tlayer)
        {
            if (tlayer == 0) { return TerrainMap; }
            if (tlayer == 1) { return DTerrainMap; }
            if (tlayer == 2) { return OwnershipMap; }
            if (tlayer == 3) { return ShroudMap; }
            if (tlayer == 4) { return UnitMap; }
            return TerrainMap;
        }

        private void InitTerrainGraphics(int tlayer)
        {
            for (int a = 0; a <= (kartanKorkeus - 1); a++)
            {
                for (int b = 0; b <= (kartanLeveys - 1); b++)
                {
                    GetGraphicsLayer(tlayer)[a, b] = new PhysicsObject(48.0, 48.0);
                }
            }
        }

        GameObject[,] GetGraphicsLayer(int tlayer)
        {
            if (tlayer == 0) {return tile; }
            if (tlayer == 1) {return DTile; }
            if (tlayer == 2) { return TileOwnership; }
            if (tlayer == 3) { return ShroudTile; }
            if (tlayer == 4) { return UnitTile; }
            return tile;
        }

        int getTerrainType(string ch, int terrainlayer, int i, int j)
        {
            if (terrainlayer == 0)
            {
                /*/ Maastotyypit
                 * 0 = lehtimetsää
                 * 1 = vuoristoa
                 * 2 = aavikkoa
                 * 3 = tundraa
                /*/
                if (ch == " ") { return Lehtimetsa; }
                if (ch == "V") { return Vuoristo; }
                if (ch == "A") { return Aavikko; }
                if (ch == "T") { return Tundra; }
            }
            else if (terrainlayer == 1)
            {
                /*/ Erikoismaastotyypit
                 * 0 = ei mitään
                 * 1 = vuoristoa
                 * 2 = metsää
                 * 3 = kuusimetsää
                /*/
                if (ch == " ") { return Tyhja; }
                if (ch == "M") { return Havumetsa; }
                if (ch == "V") { return Vuoristo; }
                if (ch == "K") { return Kuusimetsa; }
                try
                {
                    //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
                    int Playerstartloc;
                    Playerstartloc = Convert.ToInt32(ch);
                    AmountofPlayers = AmountofPlayers + 1;
                    AddStartingCity(Playerstartloc, i, j);
                    return (Playerstartloc + 10);
                }
                catch
                {
                }
                return Tyhja;
            }
            return 0;
        }

        private void TileClicked(int i, int j)
        {
            //MessageBox.Show(i + " " + j + Convert.ToString(CityPlaceSelection) + " " + Convert.ToString(UnitPositioningMode));
            //if (TileClickAllowed == true)
            //{
                if (CityPlaceSelection == true)
                {
                    if (OwnershipMap[i, j] > -1 && OwnershipMap[i, j] != CurrentPlayer)
                    {
                        MessageDisplay.Add("Ruutu on vihollisen (" + Rules.pCivs[OwnershipMap[i, j]].Name + ") hallinnassa, etkä voi rakentaa siihen kaupunkia.");
                    }
                    else
                    {
                        if (DTerrainMap[i, j] == Vuoristo | DTerrainMap[i, j] > 9)
                        {
                            if (DTerrainMap[i, j] == Vuoristo)
                            {
                                MessageDisplay.Add("Et voi rakentaa kaupunkia vuorelle!");
                            }
                            else
                            {
                                MessageDisplay.Add("Et voi rakentaa kaupunkia valmiin kaupungin päälle!");
                            }
                        }
                        else
                        {
                            bool cityAllowed = false;
                            int b;
                            int c;

                            int d;
                            int e;
                            int f;
                            for (int a = 0; a <= Rules.pCivs[CurrentPlayer].NumberofCities - 1; a++)
                            {
                                b = Rules.pCivs[CurrentPlayer].CityCoords[a, 0];
                                c = Rules.pCivs[CurrentPlayer].CityCoords[a, 1];

                                d = i - b;
                                e = j - c;
                                if (d == 2 | d == 1 | d == 0 | d == -1 | d == -2)
                                {
                                    if (e == 2 | e == 1 | e == 0 | e == -1 | e == -2)
                                    {
                                        cityAllowed = true;
                                    }
                                }
                            }
                            if (cityAllowed == true)
                            {
                                BuildCityDisp.TextColor = Color.Green;
                                BuildCityDisp.X = BuildCityDisp.X + 20;
                                Rules.pCivs[CurrentPlayer].BuiltFromCity = 0;
                                Rules.pCivs[CurrentPlayer].Production = Rules.pCivs[CurrentPlayer].Production + 10;
                                Rules.pCivs[CurrentPlayer].NumberofCities = Rules.pCivs[CurrentPlayer].NumberofCities + 1;
                                Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 0] = i;
                                Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 1] = j;
                                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
                                CityPlaceSelection = false;
                                ChangeProductionDispText();
                                DTerrainMap[i, j] = CurrentPlayer + 10;
                                DTile[i, j].Image = LoadImage(Textpath + "cityancient");
                                if (OwnershipMap[i, j] == -1)
                                {
                                    OwnershipMap[i, j] = CurrentPlayer;
                                    DrawOwnership(i, j);
                                    CheckAndRemoveShroud_FromPos(i, j);
                                }
                            }
                            else
                            {
                                MessageDisplay.Add("Valitsemasi sijainti on liian kaukana; Maksimietäisyys muista kaupungeista on 2 ruutua.");
                            }
                        }
                    }
                }
                else if (UnitPositioningMode == true)
                {
                    MessageBox.Show(Convert.ToString(UnitPositioningMode));
                    if (DTerrainMap[i, j] == CurrentPlayer + 10)
                    {
                        CreateUnit(i, j, BaseRules.Rules.getUnit_FromId(currentunit), CurrentPlayer);
                        UnitPositioningMode = false;
                        BuildUnitsClicked();
                        MessageDisplay.Add("Rakensit yksikön " + BaseRules.Rules.getUnit_FromId(currentunit).Name + " kohteeseen " + i + "; " + j + ".");
                        currentunit = -1;
                    }
                    else
                    {
                        MessageDisplay.Add("Yksikkö täytyy rakentaa kaupunkiin.");
                    }
                }
                else
                {
                    if (OwnershipMap[i, j] == 0 && UnitMap[i, j] > -1)
                    {
                        UnitSelect(i, j);
                    }
                }
            }
        //}

        private void UnitSelect(int i, int j)
        {
            //MessageBox.Show("UnitSelect: " + Convert.ToString(Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].CurrentMovementPoints));
            if (Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].CurrentMovementPoints > 0)
            {
                MessageDisplay.Add("Valitsit yksikön " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " kohteesta " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].PosX);
                MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
                UnitStatsDisp.Text = "Valittu yksikkö:" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name +
                    Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Strength + Environment.NewLine +
                    "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Movement + Environment.NewLine +
                    Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Description + Environment.NewLine + 
                    " HP: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].HP * 100 + "/100";
                SelectedUnit = GetUnit_FromPositionForSelection(i, j);
                UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
                UnitsSelected = true;
                //Keyboard.Enable(Key.NumPad1);
                //Keyboard.Enable(Key.NumPad2);
                //Keyboard.Enable(Key.NumPad3);
                //Keyboard.Enable(Key.NumPad4);
                //Keyboard.Enable(Key.NumPad5);
                //Keyboard.Enable(Key.NumPad6);
                //Keyboard.Enable(Key.NumPad7);
                //Keyboard.Enable(Key.NumPad8);
                //Keyboard.Enable(Key.NumPad9);
            }
        }
        
        private void DrawOwnership(int i, int j)
        {
            if (ShroudMap[i, j] == 0)
            {
                TileOwnership[i, j].Image = LoadImage(OwnershipColorPath + Rules.pCivs[OwnershipMap[i, j]].Color);
                //if (TileOwnership[i, j].IsAddedToGame == false | TileOwnership[i, j]. == true)
                //{
                //try
                //{
                //    Add(TileOwnership[i, j]);
                //}
                //catch
                //{
                //    //MessageDisplay.Add("TileOwnership not added at " + i + "; " + j + " ;; because of an exception.");
                //}
                //}
            }
            //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
        }

        //private void DrawUnit(int i, int j)
        //{
        //    if (UnitTile[i, j].IsAddedToGame == false)
        //    {
        //        Add(UnitTile[i, j]);
        //        //Mouse.ListenOn(UnitTile[i, j], MouseButton.Left, Jypeli.ButtonState.Pressed, UnitSelect, "Valitse yksikkö painamalla ruutua", i, j);
        //    }
        //}

        private void RemoveOwnership(int i, int j)
        {
            OwnershipMap[i, j] = -1;
            TileOwnership[i, j].Destroy();
        }

        private void AddStartingCity(int playernumber, int i, int j)
        {
            //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
            Rules.pCivs[playernumber].Production = Rules.pCivs[playernumber].Production + 10;
            Rules.pCivs[playernumber].CityCoords[Rules.pCivs[playernumber].NumberofCities, 0] = i;
            Rules.pCivs[playernumber].CityCoords[Rules.pCivs[playernumber].NumberofCities, 1] = j;
            Rules.pCivs[playernumber].NumberofCities = Rules.pCivs[playernumber].NumberofCities + 1;
            //MessageBox.Show("AddStartingCity: " + i + " " + j + " Playernumber: " + playernumber + "CityCoords: " + Rules.pCivs[playernumber].CityCoords[0, 0] + " " + Rules.pCivs[playernumber].CityCoords[0, 1]);
            if (Rules.pCivs[playernumber].HumanPlayer == false)
            {
                Rules.pCivs[playernumber].Color = setAIOwnershipColor(playernumber);
                Rules.pCivs[playernumber].Enabled = true;
                Rules.pCivs[playernumber].Name = Rules.pCivs[playernumber].Color + " " + "Empire";
            }
            else
            {
                CheckAndRemoveShroud_FromPos(i, j);
            }
            OwnershipMap[i, j] = playernumber;
            // 16. 6. 2010: Kutsutaanpa DrawOwnership sittenkin vasta kaupungin piirtämisen jälkeen (ks. InitMap ja DTilen asettaminen)
            //DrawOwnership(i, j); 

            //DTile[i, j].Image = LoadImage("\\Content\\Textures\\cityancient");
        }

        // Aliohjelma yksikön luomiseen
        private void CreateUnit(int i, int j, ALTKUnits.UnitClass unittype, int civnumber)
        {
            //MessageBox.Show(i + " " + j);
            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits] = new BaseRules.Unit();
            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].HP = 1.00;
            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosY = i;
            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosX = j;
            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].UnitType = unittype;
            Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits + 1;
            UnitMap[i, j] = civnumber;

            UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTile");

            if (OwnershipMap[i, j] == -1)
            {
            }
            else
            {
                OwnershipMap[i, j] = civnumber;
                DrawOwnership(i, j);
            }
        }

        public string GetUnits_FromPositionForView(int i, int j)
        {
            //MessageBox.Show("GetUnits...");
            string units = "";
            int civid;
            civid = OwnershipMap[i, j];
            //int[] UnitAmount = new int[23];
            //MessageBox.Show("GetUnits... Stage 0.5");
            //for (int c = 0; c <= 23; c++)
            //{
                //MessageBox.Show("GetUnits... Stage 0.8");
                //UnitAmount[c] = new int();
            //}
            //MessageBox.Show("GetUnits... Stage 1");
            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
            {
                //MessageBox.Show("GetUnits... Stage 2");
                if (Rules.pCivs[civid].Units[a].PosY == i && Rules.pCivs[civid].Units[a].PosX == j) // && (units.Contains(Rules.pCivs[civid].Units[a].UnitType.Name)))
                {
                    //MessageBox.Show("ffff");
                    // UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] = UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] + 1;
                    units = units + Rules.pCivs[civid].Units[a].UnitType.Name + "(" + BaseRules.Rules.GetUnitType_FromInt(Rules.pCivs[civid].Units[a].UnitType.UnitType) + BaseRules.Rules.GetMountedStatus_FromBool(Rules.pCivs[civid].Units[a].UnitType.Mounted) + ") HP: " + Rules.pCivs[civid].Units[a].HP * 100 + ";; " + Rules.pCivs[civid].Units[a].UnitType.Strength + " : " + 
                        Rules.pCivs[civid].Units[a].UnitType.Movement + " : " + Rules.pCivs[civid].Units[a].UnitType.Description + Environment.NewLine;
                        //UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] = Rules.pCivs[civid].Units[a].UnitType.UnitId + 1;
                }
            }
            return units;
            //}
            //return units;
            //MessageBox.Show(units);
            //MessageBox.Show("GetUnits... Stage 5");
            //for (int b = 0; b <= 23; b++)
            //{
            //    if (UnitAmount[b] > 0)
            //    {
            //        // MessageBox.Show("GetUnits... Stage 6");
            //        if (UnitAmount[b] > 1)
            //        {
            //            //MessageBox.Show("GetUnits... Stage 7");
            //            units = units + BaseRules.Rules.getUnit_FromId(UnitAmount[b]).Name + " x" + UnitAmount[b] + Environment.NewLine;
            //            return units;
            //        }
            //        else if (UnitAmount[b] == 1)
            //        {
            //             // MessageBox.Show("GetUnits... Stage 8");
            //            units = units + BaseRules.Rules.getUnit_FromId(UnitAmount[b]).Name + Environment.NewLine;
            //            return units;
            //        }
            //    }
            //}
            //return units;
            //    //MessageBox.Show("GetUnits... Stage 9");

           // MessageBox.Show("GetUnits... Stage 10");
        }

        public int GetUnit_FromPositionForSelection(int i, int j)
        {
            int civid;
            civid = OwnershipMap[i, j];
            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
            {
                if (Rules.pCivs[civid].Units[a].PosY == i && Rules.pCivs[civid].Units[a].PosX == j)
                {
                    return a;
                }
            }
            return -1;
        }

        public int GetUnit_FromPositionForRemoval(int i, int j, ALTKUnits.UnitClass unittype, double unitHP)
        {
           // MessageBox.Show("GetUnit_FromPosition: " + i + " " + j);
            int civid;
            civid = OwnershipMap[i, j];
            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
            {
                if (Rules.pCivs[civid].Units[a].PosY == i && Rules.pCivs[civid].Units[a].PosX == j && Rules.pCivs[civid].Units[a].UnitType.Equals(unittype) && Rules.pCivs[civid].Units[a].HP == unitHP)
                {
                    return a;
                }
            }
            return -1;
        }

        private void RemoveUnit(int i, int j, int civnumber, ALTKUnits.UnitClass unittype, double unitHP)
        {
            //MessageBox.Show(i + " " + j + " " + civnumber);
            int unitpos = GetUnit_FromPositionForRemoval(i, j, unittype, unitHP);
            if (unitpos > 0 && Rules.pCivs[civnumber].NumberofUnits > 2)
            {
                MessageBox.Show("FirstMethod");
                for (int a = unitpos + 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
                {
                    Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
                    Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
                    Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
                    Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
                }
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
            }
            else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits > 1)
            {
                MessageBox.Show("SecondMethod");
                for (int a = 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
                {
                    Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
                    Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
                    Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
                    Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
                }
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
            }
            else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits == 1)
            {
                MessageBox.Show("ThirdMethod");
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
            }
            Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits - 1;
        }

        public string setAIOwnershipColor(int playernumber)
        {
            int c;
            int b;
            bool ColorInUse = false;
            for (b = 0; b <= 20; b++)
            {
                ColorInUse = false;
                for (c = 0; c <= 30; c++)
                {
                    if (Rules.pCivs[c].Color == getOwnershipColor_fromInt(b))
                    {
                        ColorInUse = true;
                    }
                }
                if (ColorInUse == false)
                {
                    return getOwnershipColor_fromInt(b);
                }
            }
            return getOwnershipColor_fromInt(0);
        }

        public string getOwnershipColor_fromInt(Int32 color)
        {
            if (color == 0) { return "Aqua"; }
            if (color == 1) { return "Beige"; }
            if (color == 2) { return "Limegreen"; }
            if (color == 3) { return "Orange"; }
            if (color == 4) { return "Black"; }
            if (color == 5) { return "Red"; }
            if (color == 6) { return "Rustred"; }
            if (color == 7) { return "Yellow"; }
            if (color == 8) { return "Blue"; }
            if (color == 9) { return "Darkblue"; }
            if (color == 10) { return "Darkgreen"; }
            if (color == 11) { return "Lightblue"; }
            if (color == 12) { return "Purple"; }
            if (color == 13) { return "Darkpurple"; }
            if (color == 14) { return "Lightpurple"; }
            if (color == 15) { return "Gold"; }
            if (color == 16) { return "Silver"; }
            if (color == 17) { return "Pink"; }
            if (color == 18) { return "Teal"; }
            if (color == 19) { return "Greenyellow"; }
            if (color == 20) { return "Darkorange"; }
            if (color == 21) { return "White"; }
            if (color == 22) { return "Darkgray"; }
            return "Aqua";
        }

        string getTexture_fromTerrainType(int terraintype, int terrainlayer, int i, int j)
        {
            if (terrainlayer == 0)
            {
                if (terraintype == Lehtimetsa) { return Application.StartupPath + "\\Content\\Textures\\grassland"; }
                if (terraintype == Vuoristo) { return Application.StartupPath + "\\Content\\Textures\\mountain"; }
                if (terraintype == Aavikko) { return Application.StartupPath + "\\Content\\Textures\\desert"; }
                if (terraintype == Tundra) { return Application.StartupPath + "\\Content\\Textures\\tundra"; }
            }
            else if (terrainlayer == 1)
            {
                if (terraintype == Tyhja) { return Application.StartupPath + "\\Content\\Textures\\nothing"; }
                if (terraintype == Vuoristo) { return Application.StartupPath + "\\Content\\Textures\\mountain"; }
                if (terraintype == Havumetsa) { return Application.StartupPath + "\\Content\\Textures\\forest"; }
                if (terraintype == Kuusimetsa)
                {
                    if (TerrainMap[i, j] == 3)
                    {
                        return Application.StartupPath + "\\Content\\Textures\\spruceforestS";
                    }
                    else
                    {
                        return Application.StartupPath + "\\Content\\Textures\\spruceforest";
                    }
                }
                // Jos terraintype on 10 tai enemmän, ruudussa on pelaajan kaupunki (ks. getTerrainType)
                if (terraintype >= 10)
                {
                    if (TerrainMap[i, j] == Tundra)
                    {
                        return Application.StartupPath + "\\Content\\Textures\\cityancientTundra";
                        //DrawOwnership(i, j);
                    }
                    else
                    {
                        return Application.StartupPath + "\\Content\\Textures\\cityancient";
                    }
                }
                return Application.StartupPath + "\\Content\\Textures\\nothing";
            }
            return Application.StartupPath + "\\Content\\Textures\\grassland.jpg";
        }
        # endregion

        private void InitGUI()
        {
            TileDisp = new TextDisplay();
            TileDisp.X = Screen.Left + 120;
            TileDisp.Y = Screen.Bottom + 200;
            TileDisp.TextColor = Color.White;

            UnitStatsDisp = new TextDisplay();
            UnitStatsDisp.X = Screen.Left + 300;
            UnitStatsDisp.Y = Screen.Bottom + 400;
            UnitStatsDisp.Text = "d23";
            UnitStatsDisp.TextColor = Color.DarkRed;

            ProductionDisp = new TextDisplay();
            ProductionDisp.X = Screen.Right - 150;
            ProductionDisp.Y = Screen.Top - 50;
            ProductionDisp.Text = "Tuotanto: 10/120";
            ProductionDisp.TextColor = Color.Wheat;

            BuildCityDisp = new TextDisplay();
            BuildCityDisp.X = Screen.Right - 200;
            BuildCityDisp.Y = Screen.Top - 150;
            BuildCityDisp.TextColor = Color.Green;
            BuildCityDisp.Text = "Rakenna kaupunki";

            //Mouse.ListenOn(BuildCityDisp, MouseButton.Left, Jypeli.ButtonState.Pressed, BuildCityClicked, "Rakenna kaupunki");
            Keyboard.Listen(Key.B, Jypeli.ButtonState.Pressed, BuildCityClicked, "Rakenna kaupunki");

            BuildUnitsDisp = new TextDisplay();
            BuildUnitsDisp.X = Screen.Right - 120;
            BuildUnitsDisp.Y = Screen.Top - 200;
            BuildUnitsDisp.TextColor = Color.Green;
            BuildUnitsDisp.Text = "Rakenna yksiköitä (U)";

            Keyboard.Listen(Key.U, Jypeli.ButtonState.Pressed, BuildUnitsClicked, "Näytä yksikkövalikko");

            Unit1Disp = new TextDisplay();
            Unit1Disp.X = Screen.Right - 150;
            Unit1Disp.Y = Screen.Top - 250;
            Unit1Disp.TextColor = Color.DarkGreen;
            Unit1Disp.Text = "";

            Keyboard.Listen(Key.D1, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 1. puun yksikkö", 1);

            Unit2Disp = new TextDisplay();
            Unit2Disp.X = Screen.Right - 150;
            Unit2Disp.Y = Screen.Top - 300;
            Unit2Disp.TextColor = Color.DarkGreen;
            Unit2Disp.Text = "";

            Keyboard.Listen(Key.D2, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 2. puun yksikkö", 2);

            Unit3Disp = new TextDisplay();
            Unit3Disp.X = Screen.Right - 150;
            Unit3Disp.Y = Screen.Top - 350;
            Unit3Disp.TextColor = Color.DarkGreen;
            Unit3Disp.Text = "";

            Keyboard.Listen(Key.D3, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 3. puun yksikkö", 3);

            Unit4Disp = new TextDisplay();
            Unit4Disp.X = Screen.Right - 150;
            Unit4Disp.Y = Screen.Top - 400;
            Unit4Disp.TextColor = Color.DarkGreen;
            Unit4Disp.Text = "";

            Keyboard.Listen(Key.D4, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 4. puun yksikkö", 4);

            ResearchDisp = new TextDisplay();
            ResearchDisp.X = Screen.Right - 200;
            ResearchDisp.Y = Screen.Top - 500;
            ResearchDisp.TextColor = Color.Green;
            ResearchDisp.Text = "Teknologia:" + Environment.NewLine + "Horseback Riding 199/200";

            ResearchableTech1 = new TextDisplay();
            ResearchableTech2 = new TextDisplay();
            ResearchableTech3 = new TextDisplay();

            ClicktoResearch = new TextDisplay();
            ClicktoResearch.X = Screen.Right - 200;
            ClicktoResearch.Y = Screen.Top - 600;
            ClicktoResearch.TextColor = Color.Green;
            ClicktoResearch.Text = "Kehitä teknologiaa";

            MessageDisplay.TextColor = Color.Orange;

            Add(TileDisp);
            Add(UnitStatsDisp);
            Add(ProductionDisp);
            Add(BuildCityDisp);
            Add(BuildUnitsDisp);
            Add(Unit1Disp);
            Add(Unit2Disp);
            Add(Unit3Disp);
            Add(Unit4Disp);
            Add(ResearchDisp);
            Add(ClicktoResearch);
        }

        private void BuildUnit(int unittree)
        {
            if (UnitBuildingMode == true)
            {
                int UnitCost = new int();
                if (unittree == 1)
                {
                    UnitCost = 20;
                }
                else if (unittree == 2)
                {
                    UnitCost = 30;
                }
                else if (unittree == 3)
                {
                    UnitCost = 30;
                }
                else if (unittree == 4)
                {
                    UnitCost = 40;
                }

                if (UnitCost > CurrProduction)
                {
                    MessageDisplay.Add("Sinulla ei ole tarpeeksi tuotantoa yksikön rakentamiseen.");
                }
                else
                {
                    CurrProduction = CurrProduction - UnitCost;
                    ChangeProductionDispText();
                    MessageDisplay.Add("Rakensit yksikön " + GetBuildableUnit(unittree).Name + ". Valitse kaupunki, mihin yksikkö rakennetaan.");
                    currentunit = GetBuildableUnit(unittree).UnitId;
                    UnitPositioningMode = true;
                }
            }
            else
            {
                MessageDisplay.Add("Et ole yksikönrakennustilassa.");
            }
        }

        private ALTKUnits.UnitClass GetBuildableUnit(int unittree)
        {
            if (unittree == 1)
            {
                return BaseRules.Rules.Warrior;
            }
            if (unittree == 2)
            {
                return BaseRules.Rules.Archer;
            }
            if (unittree == 3)
            {
                return BaseRules.Rules.Spearman;
            }
            if (unittree == 4)
            {
                return BaseRules.Rules.Horseman;
            }
            return BaseRules.Rules.Warrior;
        }

        private void BuildUnitsClicked()
        {
            if (UnitPositioningMode == true)
            {
                MessageDisplay.Add("Määritä aikaisemmalle yksikölle rakennussijainti.");
            }

            if (UnitBuildingMode == true)
            {
                Unit1Disp.Text = "";
                Unit2Disp.Text = "";
                Unit3Disp.Text = "";
                Unit4Disp.Text = "";
                UnitBuildingMode = false;
            }
            else
            {
                UnitBuildingMode = true;

                // Muutetaan tekstit
                SetUnitDispText(1);
                SetUnitDispText(2);
                SetUnitDispText(3);
                SetUnitDispText(4);
            }
        }

        private void SetUnitDispText(int unitdisp)
        {
            if (unitdisp == 1)
            {
                Unit1Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T1Units[0]).Name + " [1] (20)";
            }
            else if (unitdisp == 2)
            {
                Unit2Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T2Units[0]).Name + " [2] (30)";
            }
            else if (unitdisp == 3)
            {
                Unit3Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T3Units[0]).Name + " [3] (30)";
            }
            else if (unitdisp == 4)
            {
                Unit4Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T4Units[0]).Name + " [4] (40)";
            }
        }

        private void BuildCityClicked()
        {
            TileClickAllowed = false;
            if (CityPlaceSelection == false)
            {
                Rules.pCivs[CurrentPlayer].BuiltFromCity = Rules.pCivs[CurrentPlayer].BuiltFromCity + CurrProduction;
                CurrProduction = 0;
                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
                ChangeProductionDispText();
                if (Rules.pCivs[CurrentPlayer].BuiltFromCity > Rules.pCivs[CurrentPlayer].Production | Rules.pCivs[CurrentPlayer].BuiltFromCity == Rules.pCivs[CurrentPlayer].Production)
                {
                    CurrProduction = Rules.pCivs[CurrentPlayer].BuiltFromCity - Rules.pCivs[CurrentPlayer].Production;
                    MessageDisplay.Add("Sait kaupungin valmiiksi; valitse uuden kaupungin sijainti.");
                    BuildCityDisp.Text = "Peruuta kaupungin rakentaminen (B) (" + Rules.pCivs[CurrentPlayer].Production / 2 + ")";
                    BuildCityDisp.TextColor = Color.Red;
                    BuildCityDisp.X = BuildCityDisp.X - 20;
                    ChangeProductionDispText();
                    CityPlaceSelection = true;
                }
            }
            else
            {
                BuildCityDisp.TextColor = Color.Green;
                BuildCityDisp.X = BuildCityDisp.X + 20;
                Rules.pCivs[CurrentPlayer].BuiltFromCity = 0;
                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
                CityPlaceSelection = false;
                CurrProduction = CurrProduction + (Rules.pCivs[CurrentPlayer].Production / 2);
                ChangeProductionDispText();
            }
            TileClickAllowed = true;
        }

        private void ChangeProductionDispText()
        {
            ProductionDisp.Text = "Vuoro: " + TurnNumber + Environment.NewLine +
                "Tuotantoa vuorossa: " + Rules.pCivs[CurrentPlayer].Production + Environment.NewLine +
                "Tuotantoa jäljellä: " + CurrProduction;
        }

        private void InitRules()
        {
            // Käytetään valmiiksi tehtyjä DLL-tiedostoja
            BaseRules.Rules.InitTechs();
            BaseRules.Rules.InitUnits();
            BaseRules.Rules.InitDifficulty();
            BaseRules.Rules.InitCivs();
            BaseRules.Rules.InitAIBehaviour();
        }

        private void RemoveShroud(int i, int j)
        {
            try
            {
                ShroudMap[i, j] = 0;
                ShroudTile[i, j].Destroy();
                try
                {
                    if (OwnershipMap[i, j] > -1)
                    {
                        DrawOwnership(i, j);
                    }
                }
                catch
                {
                }
            }
            catch
            {
                MessageDisplay.Add("Shroud not removed from tile " + i + "; " + j + " because of IndexoutofRange exception.");
            }
        }

        private void CheckAndRemoveShroud_FromPos(int i, int j)
        {
            RemoveShroud(i, j);
            for (int shri = i - 2; shri <= i + 2; shri++)
            {
                for (int shrj = j - 2; shrj <= j + 2; shrj++)
                {
                    RemoveShroud(shri, shrj);
                }
            }
        }

        private void TurnSystem_Start(int playernumber)
        {
            TurnNumber = TurnNumber + 1;
            MessageDisplay.Add("Vuorosi on alkanut!");
            CurrentPlayer = playernumber;
            CurrProduction = Rules.pCivs[playernumber].Production;
            ProductionDisp.Text = "Vuoro: " + TurnNumber + Environment.NewLine +
                "Tuotantoa vuorossa: " + Rules.pCivs[playernumber].Production + Environment.NewLine +
                "Tuotantoa jäljellä: " + CurrProduction;
            BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[playernumber].BuiltFromCity + " / " + Rules.pCivs[playernumber].Production + ")";
            if (TurnNumber == 1)
            {
                //CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Archer, playernumber);
                //CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Archer, playernumber);
                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Deathbringer, playernumber);
                //RemoveUnit(Rules.pCivs[playernumber].Units[0].PosY, Rules.pCivs[playernumber].Units[0].PosX, playernumber);
            }
            for (int a = 0; a < Rules.pCivs[playernumber].NumberofUnits; a++)
            {
                Rules.pCivs[playernumber].Units[a].CurrentMovementPoints = Rules.pCivs[playernumber].Units[a].UnitType.Movement;
            }
        }

        protected override void Update(Time time)
        {
            base.Update(time);
            // Mouse.PositionOnScreen voisi olla vain positiivinen, eikä ruudun pitäisi jakautua keskeltä kahtia
            // negatiivisiin ja positiivisiin kokonaislukuihin

            if (gamestarted == true)
            {
                for (int i = 0; i <= (kartanKorkeus - 1); i++)
                {
                    for (int j = 0; j <= (kartanLeveys - 1); j++)
                    {
                        if (Mouse.IsCursorOnGameObject(tile[i, j]))
                        {
                            TileDisp.Text = getTileInfo_forTileDisp(i, j);
                            if (UnitsSelected == false)
                            {
                                UnitStatsDisp.Text = getUnitDisp(i, j, 0);
                            }
                            //Application.DoEvents();
                        }
                        //Mouse.ListenMovement(tile[i, j], showTileInfo_forTileDisp, null, i, j);
                        // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
                    }
                }
                //TileDisp.Text = getTileInfo_forTileDisp(Convert.ToInt32(Mouse.PositionOnWorld.X) / -48, Convert.ToInt32(Mouse.PositionOnWorld.Y) / 48);
            if (Mouse.PositionOnScreen.X > MouseScreenWidth) { MoveCamera(0); }
            else if (Mouse.PositionOnScreen.X < NegMouseScreenWidth) { MoveCamera(2); }
            else if (Mouse.PositionOnScreen.Y > MouseScreenHeight) { MoveCamera(1); }
            else if (Mouse.PositionOnScreen.Y < NegMouseScreenHeight) { MoveCamera(3); }
            }
        }

        public string getTileInfo_forTileDisp(int i, int j)
        {
            // Haetaan tiedot ruudulle
            string tileinfo;
            int Defensebonus = new int();
            tileinfo = i + "; " + j + " :" + Environment.NewLine;
            //MessageBox.Show(i + " " + j);
            // Maaston perustiedot
            if (TerrainMap[i, j] == 0)
            {
                tileinfo = tileinfo + "Ruohotasankoa";
            }
            else if (TerrainMap[i, j] == 1)
            {
                tileinfo = tileinfo + "Vuoristoa";
            }
            else if (TerrainMap[i, j] == 2)
            {
                tileinfo = tileinfo + "Aavikkoa";
                Defensebonus = Defensebonus - 25;
            }
            else if (TerrainMap[i, j] == 3)
            {
                tileinfo = tileinfo + "Tundraa";
                Defensebonus = Defensebonus + 10;
            }

            // Erikoismaaston tiedot

            if (DTerrainMap[i, j] == 0)
            {
            }
            else if (DTerrainMap[i, j] == 1)
            {
                tileinfo = tileinfo + Environment.NewLine + "Vuoristoa" + Environment.NewLine + "Läpipääsemätön";
            }
            else if (DTerrainMap[i, j] == 2)
            {
                tileinfo = tileinfo + Environment.NewLine + "Lehtimetsää";
                Defensebonus = Defensebonus + 10;
            }
            else if (DTerrainMap[i, j] == 3)
            {
                tileinfo = tileinfo + Environment.NewLine + "Kuusimetsää";
                Defensebonus = Defensebonus + 25;
            }
            else
            {
                // MessageBox.Show(Convert.ToString(ShroudMap[i, j]));
                if (ShroudMap[i, j] == 0)
                {
                    try
                    {
                        if (OwnershipMap[i, j] >= -1)
                        {
                            tileinfo = tileinfo + Environment.NewLine + "Kaupunki";
                        }
                    }
                    catch
                    {
                    }
                }
            }

            if (ShroudMap[i, j] == 0)
            {
                try
                {
                    if (OwnershipMap[i, j] > -1)
                    {
                        tileinfo = tileinfo + Environment.NewLine + Rules.pCivs[OwnershipMap[i, j]].Name;
                    }
                }
                catch
                {
                }

                if (Defensebonus != 0)
                {
                    return tileinfo = tileinfo + Environment.NewLine + "Puolustusbonus: " + Defensebonus + "%";
                }
                else
                {
                    return tileinfo;
                }
            }
            return tileinfo;
        }

        public string getUnitDisp(int i, int j, int s)
        {
            string unitinfo = "";
            if (ShroudMap[i, j] == 0)
            {
                try
                {
                    if (OwnershipMap[i, j] > -1)
                    {
                        //MessageBox.Show("OwnershipMap passed:" + i + " " + j + " UnitMap: " + UnitMap[i, j]);
                        //MessageBox.Show(Convert.ToString(0 > -1));
                        if (UnitMap[i, j] > -1)
                        {
                            //MessageBox.Show("UnitMap passed:" + i + " " + j);
                            //string unitstats;
                            if (s == 0)
                            {
                                unitinfo = "Ruudun yksiköt: " + Environment.NewLine + GetUnits_FromPositionForView(i, j);
                            }
                            else if (s == 1)
                            {
                                unitinfo = "Valitut yksiköt: " + Environment.NewLine + GetUnits_FromPositionForView(i, j);
                            }
                        }
                    }
                }
                catch
                {
                }
            }
            return unitinfo;
        }

        private void EndTurn()
        {
            MessageDisplay.Add("Lopetit vuorosi..");
            if (SelectedUnit > -1)
            {
                DeselectUnit();
            }
            TurnSystem_Start(CurrentPlayer);
        }

        private void InitControls()
        {
            Keyboard.Listen(Key.Right, Jypeli.ButtonState.Down, MoveCamera, null, 0);
            Keyboard.Listen(Key.Left, Jypeli.ButtonState.Down, MoveCamera, null, 2);
            Keyboard.Listen(Key.Up, Jypeli.ButtonState.Down, MoveCamera, null, 1);
            Keyboard.Listen(Key.Down, Jypeli.ButtonState.Down, MoveCamera, null, 3);
            Keyboard.Listen(Key.Tab, Jypeli.ButtonState.Down, ActivateDebug, null, 0);
            Keyboard.Listen(Key.Enter, Jypeli.ButtonState.Pressed, EndTurn, null);

            Keyboard.Listen(Key.NumPad1, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä lounaaseen.", 1);
            Keyboard.Listen(Key.NumPad2, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä etelään.", 2);
            Keyboard.Listen(Key.NumPad3, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä kaakkoon.", 3);
            Keyboard.Listen(Key.NumPad4, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä länteen.", 4);
            Keyboard.Listen(Key.NumPad5, Jypeli.ButtonState.Pressed, MoveUnit, "Hyppää yksikkö yli.", 5);
            Keyboard.Listen(Key.NumPad6, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä itään.", 6);
            Keyboard.Listen(Key.NumPad7, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä luoteeseen.", 7);
            Keyboard.Listen(Key.NumPad8, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä pohjoiseen.", 8);
            Keyboard.Listen(Key.NumPad9, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä koilliseen.", 9);
            Keyboard.Listen(Key.End, Jypeli.ButtonState.Pressed, SelectUnits, "Valitsee yksiköitä.");
            Keyboard.Listen(Key.Home, Jypeli.ButtonState.Pressed, SelectNextUnit, "Valitsee seuraavan yksikön.");

            //Keyboard.Disable(Key.NumPad1);
            //Keyboard.Disable(Key.NumPad2);
            //Keyboard.Disable(Key.NumPad3);
            //Keyboard.Disable(Key.NumPad4);
            //Keyboard.Disable(Key.NumPad5);
            //Keyboard.Disable(Key.NumPad6);
            //Keyboard.Disable(Key.NumPad7);
            //Keyboard.Disable(Key.NumPad8);
            //Keyboard.Disable(Key.NumPad9);

            MouseScreenWidth = new int();
            MouseScreenWidth = Convert.ToInt32(Peli.Screen.Width / 2) - 5;
            MouseScreenHeight = new int();
            MouseScreenHeight = Convert.ToInt32(Peli.Screen.Height / 2) - 5;
            NegMouseScreenWidth = new int();
            NegMouseScreenWidth = Convert.ToInt32(Peli.Screen.Width / -2) + 5;
            NegMouseScreenHeight = new int();
            NegMouseScreenHeight = Convert.ToInt32(Peli.Screen.Height / -2) + 20;
        }

        private void EnterCombat(int i, int j, int ab, int bb)
        {
            if (DTerrainMap[i, j] > 9)
            {
                if (UnitMap[i, j] > -1)
                {

                }
                else
                {
                    CityCapture(i, j, ab, bb);
                }
            }
        }

        private void CityCapture(int i, int j, int ab, int bb)
        {
            RemoveCity_FromCivFromPosition(i, j);
            Rules.pCivs[OwnershipMap[i, j]].NumberofCities = Rules.pCivs[OwnershipMap[i, j]].NumberofCities - 1;
            Rules.pCivs[OwnershipMap[i, j]].Production = Rules.pCivs[OwnershipMap[i, j]].Production - 10;
            MessageDisplay.TextColor = Color.Red;
            MessageDisplay.Add(Rules.pCivs[CurrentPlayer].Name + " on valloittanut kaupungin ruudusta " + i + "; " + j + " (" + Rules.pCivs[OwnershipMap[i, j]].Name + ")");
            Thread.Sleep(1000);
            if (Rules.pCivs[OwnershipMap[i, j]].NumberofCities == 0)
            {
                MessageDisplay.Add(Rules.pCivs[OwnershipMap[i, j]].Name + " has been destroyed!");
                Rules.pCivs[OwnershipMap[i, j]].Enabled = false;
            }
            OwnershipMap[i, j] = CurrentPlayer;
            DrawOwnership(i, j);
            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = i;
            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = j;
            MessageDisplay.TextColor = Color.Orange;
            AddCity(i, j);

            if (GetUnit_FromPositionForSelection(ab, bb) == -1)
            {
                OwnershipMap[ab, bb] = -1;
                TileOwnership[ab, bb].Image = LoadImage(Textpath + "nothing");
            }
            DrawUnit(i, j);
        }

        private void AddCity(int i, int j)
        {
            Rules.pCivs[CurrentPlayer].Production = Rules.pCivs[CurrentPlayer].Production + 10;
            Rules.pCivs[CurrentPlayer].NumberofCities = Rules.pCivs[CurrentPlayer].NumberofCities + 1;
            Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 0] = i;
            Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 1] = j;
            BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
            CityPlaceSelection = false;
            ChangeProductionDispText();
            DTerrainMap[i, j] = CurrentPlayer + 10;
            DTile[i, j].Image = LoadImage(Textpath + "cityancient");
            CheckAndRemoveShroud_FromPos(i, j);
            if (OwnershipMap[i, j] == -1)
            {
                OwnershipMap[i, j] = CurrentPlayer;
                DrawOwnership(i, j);
                CheckAndRemoveShroud_FromPos(i, j);
            }
        }

        public int GetCityPosInArray_ForRemoval(int i, int j, int civid)
        {
            for (int a = 0; a <= Rules.pCivs[civid].NumberofCities - 1; a++)
            {
                if (Rules.pCivs[civid].CityCoords[a, 0] == i && Rules.pCivs[civid].CityCoords[a, 1] == j)
                {
                    return a;
                }
            }
            return 0;
        }

        private void RemoveCity_FromCivFromPosition(int i, int j)
        {
            int civowner = new int();
            civowner = OwnershipMap[i, j];
            int cityPosInArray = GetCityPosInArray_ForRemoval(i, j, civowner);

            if (cityPosInArray > 0 && Rules.pCivs[civowner].NumberofCities > 2)
            {
                for (int a = cityPosInArray + 1; a <= Rules.pCivs[civowner].NumberofCities - 1; a++)
                {
                    Rules.pCivs[civowner].CityCoords[a - 1, 0] = Rules.pCivs[civowner].CityCoords[a, 0];
                    Rules.pCivs[civowner].CityCoords[a - 1, 1] = Rules.pCivs[civowner].CityCoords[a, 1];
                }
                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 0] = 0;
                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 1] = 0;
            }
            else if (cityPosInArray == 0 && Rules.pCivs[civowner].NumberofCities > 1)
            {
                for (int a = 1; a <= Rules.pCivs[civowner].NumberofCities - 1; a++)
                {
                    Rules.pCivs[civowner].CityCoords[a - 1, 0] = Rules.pCivs[civowner].CityCoords[a, 0];
                    Rules.pCivs[civowner].CityCoords[a - 1, 1] = Rules.pCivs[civowner].CityCoords[a, 1];
                }
                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 0] = 0;
                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 1] = 0;
            }
            else if (Rules.pCivs[civowner].NumberofCities == 1)
            {
                Rules.pCivs[civowner].CityCoords[0, 0] = 0;
                Rules.pCivs[civowner].CityCoords[0, 1] = 0;
                Rules.pCivs[civowner].Enabled = false;
            }
        //    int unitpos = GetUnit_FromPositionForRemoval(i, j, unittype, unitHP);
        //    if (unitpos > 0 && Rules.pCivs[civnumber].NumberofUnits > 2)
        //    {
        //        MessageBox.Show("FirstMethod");
        //        for (int a = unitpos + 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
        //        {
        //            Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
        //            Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
        //            Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
        //            Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
        //        }
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
        //    }
        //    else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits > 1)
        //    {
        //        MessageBox.Show("SecondMethod");
        //        for (int a = 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
        //        {
        //            Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
        //            Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
        //            Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
        //            Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
        //        }
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
        //    }
        //    else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits == 1)
        //    {
        //        MessageBox.Show("ThirdMethod");
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
        //    }
        //    Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits - 1;
        //}
        }

        private void SelectNextUnit()
        {
            try
            {
                SelectedUnit = SelectedUnit + 1;
                UnitsSelected = true;
                UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
                MessageDisplay.Add("Valitsit yksikön " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " kohteesta " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
                UnitStatsDisp.Text = "Valittu yksikkö:" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
                    Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
                    "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
                    Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
                    " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
                return;
            }
            catch
            {
                SelectedUnit = -1;
                UnitsSelected = false;
                MessageDisplay.Add("Ei ole enempää yksiköitä valittavaksi.");
            }
        }

        private void SelectUnits()
        {
            //MessageBox.Show("SelectNextUnit");
            for (int a = 0; a <= Rules.pCivs[CurrentPlayer].NumberofUnits - 1; a++)
            {
                if (Rules.pCivs[CurrentPlayer].Units[a].CurrentMovementPoints == 1 | Rules.pCivs[CurrentPlayer].Units[a].CurrentMovementPoints > 1)
                {
                    SelectedUnit = a;
                    UnitsSelected = true;
                    UnitTile[Rules.pCivs[CurrentPlayer].Units[a].PosY, Rules.pCivs[CurrentPlayer].Units[a].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
                    MessageDisplay.Add("Valitsit yksikön " + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Name + " kohteesta " + Rules.pCivs[CurrentPlayer].Units[a].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[a].PosX);
                    MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
                    UnitStatsDisp.Text = "Valittu yksikkö:" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Name +
                        Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Strength + Environment.NewLine +
                        "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Movement + Environment.NewLine +
                        Rules.pCivs[CurrentPlayer].Units[a].UnitType.Description + Environment.NewLine +
                        " HP: " + Rules.pCivs[CurrentPlayer].Units[a].HP * 100 + "/100";
                    return;
                }
            }
        }

        private void MoveUnit(int direction)
        {
            if (SelectedUnit == -1)
            {
                MessageDisplay.Add("Ei ole yksikköä valittuna.");
            }
            else
            {
                if (direction == 1)
                {
                    UnitMovementMain(-1, -1);
                }
                else if (direction == 2)
                {
                    UnitMovementMain(-1, 0);
                }
                else if (direction == 3)
                {
                    UnitMovementMain(-1, 1);
                }
                else if (direction == 4)
                {
                    UnitMovementMain(0, -1);
                }
                else if (direction == 5)
                {
                    //SelectNextUnitOnTile(-1, 0);
                }
                else if (direction == 6)
                {
                    UnitMovementMain(0, 1);
                }
                else if (direction == 7)
                {
                    UnitMovementMain(1, -1);
                }
                else if (direction == 8)
                {
                    UnitMovementMain(1, 0);
                }
                else if (direction == 9)
                {
                    UnitMovementMain(1, 1);
                }
                if (Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints == 0)
                {
                    DeselectUnit();
                }
                else
                {
                    UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
                }
            }
            //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX - 1;
            //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY - 1;
            //OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
            //DrawOwnership(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
            //UnitMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
            //DrawUnit(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
            //CheckAndRemoveShroud_FromPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
            //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints - 1;
            //if (GetUnit_FromPositionForSelection(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1) == -1)
            //{
            //    UnitMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1] = -1;
            //    UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1].Destroy();
            //    if (CheckforCityinPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1, CurrentPlayer) == -1)
            //    {
            //        OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1] = -1;
            //        TileOwnership[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + 1, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + 1].Destroy();
            //    }
            //}
        }

        private void UnitMovementMain(int a, int b)
        {
            if (TerrainMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b] == Vuoristo | DTerrainMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b] == Vuoristo)
            {
                MessageDisplay.Add("Et voi liikkua vuorten läpi!");
            }
            else
            {
                if (Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints == 0 | Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints < 0)
                {
                    MessageDisplay.Add("Valitulla yksiköllä ei ollut liikkumapisteitä.");
                    return;
                }
                if (OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b] != -1 && OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b] != (CurrentPlayer + 10))
                {
                    EnterCombat(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                    return;
                }
                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b;
                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a;
                // MessageBox.Show(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + " " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                //try
                //{
                int posyK;
                int posxK;
                posyK = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1);
                posxK = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1);
                OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
                DrawOwnership(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                UnitMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
                CheckAndRemoveShroud_FromPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints - 1;
                DrawUnit(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
                //MessageBox.Show(Convert.ToString(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints));
                if (GetUnit_FromPositionForSelection(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)) == -1)
                {
                    UnitMap[posyK, posxK] = -1;
                    UnitTile[posyK, posxK].Image = LoadImage(Textpath + "nothing");
                    if (CheckforCityinPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1), CurrentPlayer) == -1)
                    {
                        OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)] = -1;
                        TileOwnership[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)].Image = LoadImage(Textpath + "nothing");
                    }
                }
                //catch
                //{
                //MessageDisplay.Add("Et voi liikkua kartan ulkopuolelle!");
                //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX - b;
                //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY - a;
                //}
                //}
            }
        }

        private void DrawUnit(int i, int j)
        {
            UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
            UnitTile[i, j].IsVisible = true;
            //Add(UnitTile[i, j]);
        }

        private void DeselectUnit()
        {
                UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTile");
                UnitsSelected = false;
                SelectedUnit = -1;
                //Keyboard.Disable(Key.NumPad1);
                //Keyboard.Disable(Key.NumPad2);
                //Keyboard.Disable(Key.NumPad3);
                //Keyboard.Disable(Key.NumPad4);
                //Keyboard.Disable(Key.NumPad5);
                //Keyboard.Disable(Key.NumPad6);
                //Keyboard.Disable(Key.NumPad7);
                //Keyboard.Disable(Key.NumPad8);
                //Keyboard.Disable(Key.NumPad9);
        }

        public int CheckforCityinPos(int i, int j, int civid)
        {
            int returnvalue = new int();
            if (DTerrainMap[i, j] - 10 == civid)
            {
                returnvalue = civid;
            }
            else
            {
                returnvalue = -1;
            }
            return returnvalue;
        }

        private void ActivateDebug(int asd)
        {
            //Add(MessageDisplay);
            MessageDisplay.Add("DEBUG MODE ACTIVATED");
            Keyboard.Listen(Key.A, Jypeli.ButtonState.Down, ShowColors, null);
        }

        private void ShowColors()
        {
            for (int a = 0; a <= (AmountofPlayers - 1); a++)
            {
                MessageDisplay.Add("Pelaaja: " + a + "; " + Rules.pCivs[a].Color);
            }
        }

        private void MoveCamera(Int32 dir)
        {
            if (gamestarted == false) { return; }
            if ((dir == 0)  && (Camera.Position.X < (tile[kartanKorkeus - 1, kartanLeveys - 1].X) - ((Peli.Screen.Width / 2) - 200)))
            {
                Camera.Move(CamSpeedEast);
            }
            if ((dir == 1) && (Camera.Position.Y < (tile[kartanKorkeus - 1, kartanLeveys - 1].Y) - ((Peli.Screen.Height / 2) - 12)))
            {
                Camera.Move(CamSpeedNorth);
            }
            if ((dir == 2) && (Camera.Position.X > (tile[0, 0].X) + (Peli.Screen.Width / 2)))
            {
                Camera.Move(CamSpeedWest);
            }
            if ((dir == 3) && (Camera.Position.Y > (tile[0, 0].Y) + (Peli.Screen.Height / 2)))
            {
                Camera.Move(CamSpeedSouth);
            }
        }
    }
}