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

Revision 999, 134.0 KB checked in by ramipasa, 12 years ago (diff)

Korjattu eräs bugi tekoälyn archerinrakentamisesta valloitettuihin kaupunkeihin, jonka takia tekoäly ei rakentanut archereita ollenkaan.

Line 
1using System;                        // Tämän tarpeellisuus pitäisi olla itsestäänselvyys
2using Jypeli;                        // Jypeli
3using Jypeli.ScreenObjects;          // Jypeli.ScreenObjects
4using Jypeli.Assets;                 // Jypeli.Assets
5using System.Collections.Generic;    // Jypelin tutoriaali
6using System.IO;                     // Streamreader vaatii tämän
7using System.Windows.Forms;          // jotta voin näyttää msgboxeja
8using ALTKTechs;                     // Avaruuslaatikon moottorikomponentit
9using ALTKUnits;
10using ALTKCiv;
11using ALTKPromotions;
12using ALTKDiff;
13using ALTKAIBehaviour;
14using BaseRules;                     // Avaruuslaatikon sääntötiedosto, helpottaa modien tekemistä
15using System.Threading;              // voin käyttää Thread.Sleepiä
16
17namespace ALTKTileEngine
18{
19    public class Peli : Game
20    {
21        bool gamestarted = false;
22        int currDiffLevel; // jotta tätä voidaan käyttää missä tahansa
23
24        int[,] TerrainMap; // perusmaastokartta
25        int[,] DTerrainMap; // erikoismaastokartta
26        int[,] OwnershipMap; // ruudukon omistuskartta (kenen pelaajan hallinnassa on mikäkin ruutu)
27        int[,] ShroudMap; // pelaajan näkymää pienentävä Shroudmap
28        int[,] UnitMap; // yksikkökartta
29
30        int[,] AIPaths; // skriptitekoälylle
31        int[] AIPathLenghts = new int[4];
32
33        string Textpath;
34        string OwnershipColorPath;
35
36        int AmountofPlayers; // Ihmispelaajien määrä, tällä hetkellä peli tukee vain yhtä
37        int TurnNumber; // vuoron numero
38        int CurrProduction; // pelaajan tämänhetkinen tuotanto
39        int PlayerAmount = 2;
40
41        int PlayerCapitalCoordY;
42        int PlayerCapitalCoordX;
43
44        int AICapitalCoordY;
45        int AICapitalCoordX;
46        // !!!!!!!!!!!!!!!!!!!!!!!!!!!
47        // Pitänee tehdä vielä yksi ALTKSUnit-namespace ALTKCoreen.
48        // Tämä sisältäisi tiedot yksiköiden omistajasta, yksikön perusyksiköstä ym. sekä myös karttakoordinaatit
49        // (karttakoordinaatit säilyttää myös UnitMap, josta on helppo tarkastaa esim. liikuttaessa yksiköitä, onko ruudussa jo esim. vihollisyksiköitä.
50
51        int SelectedUnit = -1;
52        int AISelectedUnit = -1;
53
54        bool UnitsSelected = new bool();
55
56        TextDisplay TileDisp;
57        TextDisplay UnitStatsDisp;
58        TextDisplay ProductionDisp;
59        TextDisplay BuildCityDisp;
60        TextDisplay BuildUnitsDisp;
61        TextDisplay Unit1Disp;
62        TextDisplay Unit2Disp;
63        TextDisplay Unit3Disp;
64        TextDisplay Unit4Disp;
65        TextDisplay ResearchDisp;
66        TextDisplay ResearchableTech1;
67        TextDisplay ResearchableTech2;
68        TextDisplay ResearchableTech3;
69        TextDisplay ClicktoResearch;
70
71        bool CombatEnabled = false;
72
73        int kartanLeveys;
74        int kartanKorkeus;
75
76        int CurrentPlayer;
77
78        bool CityPlaceSelection;
79        bool TileClickAllowed = false;
80
81        bool UnitBuildingMode = false;
82        bool UnitPositioningMode = false;
83        int currentunit = new int();
84
85        // perusmaastotyypit
86        const int Aavikko = 2, Tundra = 3, Vuoristo = 1, Lehtimetsa = 0;
87
88        // erikoismaastotyypit
89        const int Havumetsa = 2, Tyhja = 0, Kuusimetsa = 3;
90
91        // Pelissä on viisi eri tasoa, toisella perusmaasto ja toisella tarkempaa tietoa (esim. onko ruutu metsää ym.)
92        // Kolmas taso kertoo, kenen valtion hallinnassa ruutu on, neljäs on Fog of War, ja viides piirtää yksiköt.
93        GameObject[,] tile;
94        GameObject[,] DTile;
95        GameObject[,] TileOwnership;
96        GameObject[,] ShroudTile;
97        GameObject[,] UnitTile;
98        //Vector tileVector;
99
100        Vector CamSpeedEast = new Vector(20.0, .0);
101        Vector CamSpeedWest = new Vector(-20.0, .0);
102        Vector CamSpeedNorth = new Vector(.0, 20.0);
103        Vector CamSpeedSouth = new Vector(.0, -20.0);
104
105        // Käytän ennemmin enemmän muistia kuin prosessoria, joten lasken nämä jo täällä
106        int MouseScreenWidth;
107        int MouseScreenHeight;
108        int NegMouseScreenWidth;
109        int NegMouseScreenHeight;
110        # region Aloitusruutuvalikko
111        protected override void Begin()
112        {
113            //SetWindowSize(true);
114            Textpath = Application.StartupPath + "\\Content\\Textures\\";
115            OwnershipColorPath = Textpath + "Ownership\\";
116            InitRules();
117            InitStartMenu();
118            //InitControls();
119            //InitMap();
120        }
121        void InitStartMenu()
122        {
123            Level.BackgroundColor = Color.Gray;
124            Mouse.Enabled = true;
125            Mouse.IsCursorVisible = true;
126
127            InputQueryWindow input = new InputQueryWindow();
128            input.InputConfirmed += Player_SetName;
129            input.QueryText.Text = "Kirjoita valtiosi nimi:";
130            input.Size = new Vector(300.0, 100.0);
131            input.Position = new Vector(-250.0, 350.0);
132            input.InputBox.BorderColor = Color.GreenYellow;
133            ShowWindow(input);
134
135            GameObject TrainingButton = new GameObject(250, 30, Shapes.Rectangle);
136            GameObject EasyButton = new GameObject(250, 30, Shapes.Rectangle);
137            GameObject NormalButton = new GameObject(250, 30, Shapes.Rectangle);
138            GameObject HardButton = new GameObject(250, 30, Shapes.Rectangle);
139            GameObject VHardButton = new GameObject(250, 30, Shapes.Rectangle);
140            GameObject NightmareButton = new GameObject(250, 30, Shapes.Rectangle);
141            GameObject InsanityButton = new GameObject(250, 30, Shapes.Rectangle);
142
143            for (int a = 0; a <= 6; a++)
144            {
145                if (a == 0) { SetDiffButton(TrainingButton, 0); }
146                if (a == 1) { SetDiffButton(EasyButton, 1); }
147                if (a == 2) { SetDiffButton(NormalButton, 2); }
148                if (a == 3) { SetDiffButton(HardButton, 3); }
149                if (a == 4) { SetDiffButton(VHardButton, 4); }
150                if (a == 5) { SetDiffButton(NightmareButton, 5); }
151                if (a == 6) { SetDiffButton(InsanityButton, 6); }
152            }
153            Mouse.ListenOn(TrainingButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 0);
154            Mouse.ListenOn(EasyButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 1);
155            Mouse.ListenOn(NormalButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 2);
156            Mouse.ListenOn(HardButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 3);
157            Mouse.ListenOn(VHardButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 4);
158            Mouse.ListenOn(NightmareButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 5);
159            Mouse.ListenOn(InsanityButton, MouseButton.Left, Jypeli.ButtonState.Down, SelectDifficulty, "", 6);
160        }
161
162        void Player_SetName(InputQueryWindow sender, string input)
163        {
164            Rules.pCivs[0].Name = input;
165            Rules.pCivs[0].HumanPlayer = true;
166            Rules.pCivs[0].Enabled = true;
167            Rules.pCivs[0].Color = "red";
168        }
169
170        void SetDiffButton(GameObject diffbutton, int difflevel)
171        {
172            diffbutton.X = 250;
173            diffbutton.Y = ((difflevel * -50) + 300);
174            if (difflevel == 0) { diffbutton.Image = LoadImage(Textpath + "training"); }
175            else if (difflevel == 1) { diffbutton.Image = LoadImage(Textpath + "easy"); }
176            else if (difflevel == 2) { diffbutton.Image = LoadImage(Textpath + "normal"); }
177            else if (difflevel == 3) { diffbutton.Image = LoadImage(Textpath + "hard"); }
178            else if (difflevel == 4) { diffbutton.Image = LoadImage(Textpath + "vhard"); }
179            else if (difflevel == 5) { diffbutton.Image = LoadImage(Textpath + "nightmare"); }
180            else if (difflevel == 6) { diffbutton.Image = LoadImage(Textpath + "insanity"); }
181            Add(diffbutton);
182            //return diffbutton;
183        }
184
185        void SelectDifficulty(int difflevel)
186        {
187            ClearAll();
188            currDiffLevel = new int();
189            currDiffLevel = difflevel;
190            InitControls();
191            InitMap();
192            gamestarted = true;
193        }
194        # endregion
195        # region Kartan luominen
196
197        void InitMap()
198        {
199            // laitetaanpa nämä AIPathsit tänne ihan vain selkeyden vuoksi
200            AIPaths = new int[4, 50];
201
202            // reitti 1
203            AIPathLenghts[0] = 30;
204
205            AIPaths[0, 0] = 0;
206            AIPaths[0, 1] = 8;
207            AIPaths[0, 2] = 8;
208            AIPaths[0, 3] = 8;
209            AIPaths[0, 4] = 6;
210            AIPaths[0, 5] = 6;
211            AIPaths[0, 6] = 6;
212            AIPaths[0, 7] = 6;
213            AIPaths[0, 8] = 6;
214            AIPaths[0, 9] = 6;
215            AIPaths[0, 10] = 8;
216            AIPaths[0, 11] = 8;
217            AIPaths[0, 12] = 6;
218            AIPaths[0, 13] = 6;
219            AIPaths[0, 14] = 6;
220            AIPaths[0, 15] = 6;
221            AIPaths[0, 16] = 6;
222            AIPaths[0, 17] = 6;
223            AIPaths[0, 18] = 6;
224            AIPaths[0, 19] = 6;
225            AIPaths[0, 20] = 6;
226            AIPaths[0, 21] = 6;
227            AIPaths[0, 22] = 6;
228            AIPaths[0, 23] = 6;
229            AIPaths[0, 24] = 6;
230            AIPaths[0, 25] = 6;
231            AIPaths[0, 26] = 6;
232            AIPaths[0, 27] = 6;
233            AIPaths[0, 28] = 6;
234            AIPaths[0, 29] = 6;
235            AIPaths[0, 30] = 6;
236
237            // reitti 2
238
239            AIPathLenghts[1] = 29;
240
241            AIPaths[1, 0] = 0;
242            AIPaths[1, 1] = 6;
243            AIPaths[1, 2] = 6;
244            AIPaths[1, 3] = 6;
245            AIPaths[1, 4] = 6;
246            AIPaths[1, 5] = 6;
247            AIPaths[1, 6] = 6;
248            AIPaths[1, 7] = 6;
249            AIPaths[1, 8] = 6;
250            AIPaths[1, 9] = 6;
251            AIPaths[1, 10] = 6;
252            AIPaths[1, 11] = 6;
253            AIPaths[1, 12] = 6;
254            AIPaths[1, 13] = 8;
255            AIPaths[1, 14] = 6;
256            AIPaths[1, 15] = 6;
257            AIPaths[1, 16] = 6;
258            AIPaths[1, 17] = 6;
259            AIPaths[1, 18] = 6;
260            AIPaths[1, 19] = 8;
261            AIPaths[1, 20] = 6;
262            AIPaths[1, 21] = 6;
263            AIPaths[1, 22] = 6;
264            AIPaths[1, 23] = 6;
265            AIPaths[1, 24] = 6;
266            AIPaths[1, 25] = 6;
267            AIPaths[1, 26] = 8;
268            AIPaths[1, 27] = 6;
269            AIPaths[1, 28] = 8;
270            AIPaths[1, 29] = 8;
271
272            TurnNumber = new int();
273            AmountofPlayers = new int();
274            Int32 i;
275            Int32 j;
276            string mLine;
277            TextReader bReader;
278            bReader = new StreamReader("Content\\Maps\\1\\base.txt");
279            //try
280            //{
281
282            // Yleensä kartan kaksi ensimmäistä riviä ovat kommentteja
283            bReader.ReadLine();
284            bReader.ReadLine();
285
286            kartanLeveys = Convert.ToInt32(bReader.ReadLine().Substring(9, 2));
287            kartanKorkeus = Convert.ToInt32(bReader.ReadLine().Substring(10, 2));
288
289            Int32 mapWidthJ = (kartanLeveys * 48) / 2;
290            Int32 mapHeightJ = (kartanKorkeus * 48) / 2;
291
292            bReader.ReadLine();
293            // Ladataan TerrainMapit muistiin myöhempää käyttöä varten
294
295            TerrainMap = new int[kartanKorkeus, kartanLeveys];
296            DTerrainMap = new int[kartanKorkeus, kartanLeveys];
297            OwnershipMap = new int[kartanKorkeus, kartanLeveys];
298            ShroudMap = new int[kartanKorkeus, kartanLeveys];
299            UnitMap = new int[kartanKorkeus, kartanLeveys];
300            InitTerrain(0);
301            InitTerrain(1);
302            InitTerrain(2);
303            InitTerrain(3);
304            InitTerrain(4);
305
306            tile = new GameObject[kartanKorkeus, kartanLeveys];
307            DTile = new GameObject[kartanKorkeus, kartanLeveys];
308            TileOwnership = new GameObject[kartanKorkeus, kartanLeveys];
309            ShroudTile = new GameObject[kartanKorkeus, kartanLeveys];
310            UnitTile = new GameObject[kartanKorkeus, kartanLeveys];
311            InitTerrainGraphics(0);
312            InitTerrainGraphics(1);
313            InitTerrainGraphics(2);
314            InitTerrainGraphics(3);
315            InitTerrainGraphics(4);
316
317            for (i = 0; i <= (kartanKorkeus - 1); i++)
318            {
319                for (j = 0; j <= (kartanLeveys - 1); j++)
320                {
321                    UnitMap[i, j] = -1;
322                }
323            }
324
325            // Initialisoidaan Unitmap
326
327            for (i = 0; i <= (kartanKorkeus - 1); i++)
328            {
329                for (j = 0; j <= (kartanLeveys - 1); j++)
330                {
331                    UnitTile[i, j].Shape = Shapes.Rectangle;
332                    UnitTile[i, j].X = (j * 48) - mapWidthJ;
333                    UnitTile[i, j].Y = (i * 48) - mapHeightJ;
334                    UnitTile[i, j].Image = LoadImage(Textpath + "nothing");
335                    Add(UnitTile[i, j]);
336                }
337            }
338
339            // Koodi käännetty RGE:n VB.netistä
340            // Asettaa ja piirtää pohjamaaston
341
342            for (i = 0; i <= (kartanKorkeus - 1); i++)
343            {
344                mLine = bReader.ReadLine();
345                for (j = 0; j <= (kartanLeveys - 1); j++)
346                {
347                    // MessageBox.Show(mLine + " " + j + " " + i);s
348                    tile[i, j].Shape = Shapes.Rectangle;
349                    tile[i, j].X = (j * 48) - mapWidthJ;
350                    tile[i, j].Y = (i * 48) - mapHeightJ;
351                    TerrainMap[i, j] = getTerrainType(mLine.Substring(j, 1), 0, i, j);
352                    tile[i, j].Image = LoadImage(getTexture_fromTerrainType(TerrainMap[i, j], 0, i, j));
353                    Add(tile[i, j]);
354                    Mouse.ListenOn(tile[i, j], MouseButton.Left, Jypeli.ButtonState.Released, TileClicked, "", i, j);
355                    //Mouse.ListenMovement(tile[i, j], showTileInfo_forTileDisp, null, i, j);
356                    // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
357                }
358            }
359
360            // Luetaan karttatiedoston rivivälit
361            bReader.ReadLine();
362            bReader.ReadLine();
363
364            // Rami 16. 6. 2010: Omistuskartta pitää sittenkin säätää ennen erikoismaastoa, sillä
365            // kaupungit ja omistusrinki piirretään erikoismaaston asettamiskoodin kutsusta
366            for (i = 0; i <= (kartanKorkeus - 1); i++)
367            {
368                for (j = 0; j <= (kartanLeveys - 1); j++)
369                {
370                    // MessageBox.Show(mLine + " " + j + " " + i);
371                    OwnershipMap[i, j] = -1;
372                    TileOwnership[i, j].Shape = Shapes.Rectangle;
373                    TileOwnership[i, j].X = (j * 48) - mapWidthJ;
374                    TileOwnership[i, j].Y = (i * 48) - mapHeightJ;
375                    TileOwnership[i, j].Image = LoadImage(Textpath + "nothing");
376                    Add(TileOwnership[i, j]);
377                    //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
378                    // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
379                }
380            }
381
382            // Initialisoidaan Shroudmap
383
384            for (i = 0; i <= (kartanKorkeus - 1); i++)
385            {
386                for (j = 0; j <= (kartanLeveys - 1); j++)
387                {
388                    ShroudMap[i, j] = 1;
389                    ShroudTile[i, j].Shape = Shapes.Rectangle;
390                    ShroudTile[i, j].X = (j * 48) - mapWidthJ;
391                    ShroudTile[i, j].Y = (i * 48) - mapHeightJ;
392                    ShroudTile[i, j].Image = LoadImage(Textpath + "fogofwar");
393                }
394            }
395
396
397            // Asettaa ja piirtää erikoismaaston
398
399            for (i = 0; i <= (kartanKorkeus - 1); i++)
400            {
401                mLine = bReader.ReadLine();
402                for (j = 0; j <= (kartanLeveys - 1); j++)
403                {
404                    DTile[i, j].Shape = Shapes.Rectangle;
405                    DTile[i, j].X = (j * 48) - mapWidthJ;
406                    DTile[i, j].Y = (i * 48) - mapHeightJ;
407                    DTerrainMap[i, j] = getTerrainType(mLine.Substring(j, 1), 1, i, j);
408                    DTile[i, j].Image = LoadImage(getTexture_fromTerrainType(DTerrainMap[i, j], 1, i, j));
409                    Add(DTile[i, j]);
410                    if (getTexture_fromTerrainType(DTerrainMap[i, j], 1, i, j).Contains("city"))
411                    {
412                        DrawOwnership(i, j);
413                    }
414                }
415            }
416
417            // Piirretään ShroudTile vasta tässä, jotta se olisi DTilen päällä
418            for (i = 0; i <= (kartanKorkeus - 1); i++)
419            {
420                for (j = 0; j <= (kartanLeveys - 1); j++)
421                {
422                    if (ShroudMap[i, j] == 1)
423                    {
424                       Add(ShroudTile[i, j]);
425                    }
426                }
427            }
428
429            //catch
430            //{
431            //    MessageBox.Show("Map error!");
432            //    bReader.Close();
433            //    Exit();
434            //}
435            bReader.Close();
436            //for (int playernumber = 0; playernumber <= 30; playernumber++)
437            //{
438            //    Rules.pCivs[playernumber].Color = setAIOwnershipColor(playernumber);
439            //}
440            Level.BackgroundColor = Color.Black;
441            InitGUI();
442
443            Application.DoEvents();
444            TurnSystem_Start(0); // Antaa pelin alkaa!
445        }
446
447        private void InitTerrain(int tlayer)
448        {
449            for (int a = 0; a <= (kartanKorkeus - 1); a++)
450            {
451                for (int b = 0; b <= (kartanLeveys - 1); b++)
452                {
453                    GetTerrainLayer(tlayer)[a, b] = new int();
454                }
455            }
456        }
457
458        int[,] GetTerrainLayer(int tlayer)
459        {
460            if (tlayer == 0) { return TerrainMap; }
461            if (tlayer == 1) { return DTerrainMap; }
462            if (tlayer == 2) { return OwnershipMap; }
463            if (tlayer == 3) { return ShroudMap; }
464            if (tlayer == 4) { return UnitMap; }
465            return TerrainMap;
466        }
467
468        private void InitTerrainGraphics(int tlayer)
469        {
470            for (int a = 0; a <= (kartanKorkeus - 1); a++)
471            {
472                for (int b = 0; b <= (kartanLeveys - 1); b++)
473                {
474                    GetGraphicsLayer(tlayer)[a, b] = new PhysicsObject(48.0, 48.0);
475                }
476            }
477        }
478
479        GameObject[,] GetGraphicsLayer(int tlayer)
480        {
481            if (tlayer == 0) {return tile; }
482            if (tlayer == 1) {return DTile; }
483            if (tlayer == 2) { return TileOwnership; }
484            if (tlayer == 3) { return ShroudTile; }
485            if (tlayer == 4) { return UnitTile; }
486            return tile;
487        }
488
489        int getTerrainType(string ch, int terrainlayer, int i, int j)
490        {
491            if (terrainlayer == 0)
492            {
493                /*/ Maastotyypit
494                 * 0 = lehtimetsää
495                 * 1 = vuoristoa
496                 * 2 = aavikkoa
497                 * 3 = tundraa
498                /*/
499                if (ch == " ") { return Lehtimetsa; }
500                if (ch == "V") { return Vuoristo; }
501                if (ch == "A") { return Aavikko; }
502                if (ch == "T") { return Tundra; }
503            }
504            else if (terrainlayer == 1)
505            {
506                /*/ Erikoismaastotyypit
507                 * 0 = ei mitään
508                 * 1 = vuoristoa
509                 * 2 = metsää
510                 * 3 = kuusimetsää
511                /*/
512                if (ch == " ") { return Tyhja; }
513                if (ch == "M") { return Havumetsa; }
514                if (ch == "V") { return Vuoristo; }
515                if (ch == "K") { return Kuusimetsa; }
516                try
517                {
518                    //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
519                    int Playerstartloc;
520                    Playerstartloc = Convert.ToInt32(ch);
521                    AmountofPlayers = AmountofPlayers + 1;
522                    AddStartingCity(Playerstartloc, i, j);
523                    return (Playerstartloc + 10);
524                }
525                catch
526                {
527                }
528                return Tyhja;
529            }
530            return 0;
531        }
532
533        private void TileClicked(int i, int j)
534        {
535            //MessageBox.Show(i + " " + j + Convert.ToString(CityPlaceSelection) + " " + Convert.ToString(UnitPositioningMode));
536            //if (TileClickAllowed == true)
537            //{
538                if (CityPlaceSelection == true)
539                {
540                    if (OwnershipMap[i, j] > -1 && OwnershipMap[i, j] != CurrentPlayer)
541                    {
542                        MessageDisplay.Add("Ruutu on vihollisen (" + Rules.pCivs[OwnershipMap[i, j]].Name + ") hallinnassa, etkä voi rakentaa siihen kaupunkia.");
543                    }
544                    else
545                    {
546                        if (DTerrainMap[i, j] == Vuoristo | DTerrainMap[i, j] > 9)
547                        {
548                            if (DTerrainMap[i, j] == Vuoristo)
549                            {
550                                MessageDisplay.Add("Et voi rakentaa kaupunkia vuorelle!");
551                            }
552                            else
553                            {
554                                MessageDisplay.Add("Et voi rakentaa kaupunkia valmiin kaupungin päälle!");
555                            }
556                        }
557                        else
558                        {
559                            bool cityAllowed = false;
560                            int b;
561                            int c;
562
563                            int d;
564                            int e;
565                            int f;
566                            for (int a = 0; a <= Rules.pCivs[CurrentPlayer].NumberofCities - 1; a++)
567                            {
568                                b = Rules.pCivs[CurrentPlayer].CityCoords[a, 0];
569                                c = Rules.pCivs[CurrentPlayer].CityCoords[a, 1];
570
571                                d = i - b;
572                                e = j - c;
573                                if (d == 2 | d == 1 | d == 0 | d == -1 | d == -2)
574                                {
575                                    if (e == 2 | e == 1 | e == 0 | e == -1 | e == -2)
576                                    {
577                                        cityAllowed = true;
578                                    }
579                                }
580                            }
581                            if (cityAllowed == true)
582                            {
583                                BuildCityDisp.TextColor = Color.Green;
584                                BuildCityDisp.X = BuildCityDisp.X + 20;
585                                Rules.pCivs[CurrentPlayer].BuiltFromCity = 0;
586                                Rules.pCivs[CurrentPlayer].Production = Rules.pCivs[CurrentPlayer].Production + 10;
587                                Rules.pCivs[CurrentPlayer].NumberofCities = Rules.pCivs[CurrentPlayer].NumberofCities + 1;
588                                Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 0] = i;
589                                Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 1] = j;
590                                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
591                                CityPlaceSelection = false;
592                                ChangeProductionDispText();
593                                DTerrainMap[i, j] = CurrentPlayer + 10;
594                                DTile[i, j].Image = LoadImage(Textpath + "cityancient");
595                                if (OwnershipMap[i, j] == -1)
596                                {
597                                    OwnershipMap[i, j] = CurrentPlayer;
598                                    DrawOwnership(i, j);
599                                    CheckAndRemoveShroud_FromPos(i, j);
600                                }
601                            }
602                            else
603                            {
604                                MessageDisplay.Add("Valitsemasi sijainti on liian kaukana; Maksimietäisyys muista kaupungeista on 2 ruutua.");
605                            }
606                        }
607                    }
608                }
609                else if (UnitPositioningMode == true)
610                {
611                    if (DTerrainMap[i, j] == CurrentPlayer + 10)
612                    {
613                        CreateUnit(i, j, BaseRules.Rules.getUnit_FromId(currentunit), CurrentPlayer);
614                        UnitPositioningMode = false;
615                        //BuildUnitsClicked(); kävi liian ärsyttäväksi
616                        MessageDisplay.Add("Rakensit yksikön " + BaseRules.Rules.getUnit_FromId(currentunit).Name + " kohteeseen " + i + "; " + j + ".");
617                        currentunit = -1;
618                    }
619                    else
620                    {
621                        MessageDisplay.Add("Yksikkö täytyy rakentaa kaupunkiin.");
622                    }
623                }
624                else
625                {
626                    if (OwnershipMap[i, j] == 0 && UnitMap[i, j] > -1)
627                    {
628                        UnitSelect(i, j);
629                    }
630                }
631            }
632        //}
633
634        private void UnitSelect(int i, int j)
635        {
636            //MessageBox.Show("UnitSelect: " + Convert.ToString(Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].CurrentMovementPoints));
637            if (Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].CurrentMovementPoints > 0)
638            {
639                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);
640                MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
641                UnitStatsDisp.Text = "Valittu yksikkö" + "(" + i + "; " + j + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name +
642                    Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Strength + Environment.NewLine +
643                    "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Movement + Environment.NewLine +
644                    Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Description + Environment.NewLine + 
645                    " HP: " + Rules.pCivs[CurrentPlayer].Units[GetUnit_FromPositionForSelection(i, j)].HP * 100 + "/100";
646                SelectedUnit = GetUnit_FromPositionForSelection(i, j);
647                UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
648                UnitsSelected = true;
649                //Keyboard.Enable(Key.NumPad1);
650                //Keyboard.Enable(Key.NumPad2);
651                //Keyboard.Enable(Key.NumPad3);
652                //Keyboard.Enable(Key.NumPad4);
653                //Keyboard.Enable(Key.NumPad5);
654                //Keyboard.Enable(Key.NumPad6);
655                //Keyboard.Enable(Key.NumPad7);
656                //Keyboard.Enable(Key.NumPad8);
657                //Keyboard.Enable(Key.NumPad9);
658            }
659        }
660       
661        private void DrawOwnership(int i, int j)
662        {
663            if (ShroudMap[i, j] == 0)
664            {
665                TileOwnership[i, j].Image = LoadImage(OwnershipColorPath + Rules.pCivs[OwnershipMap[i, j]].Color);
666                //if (TileOwnership[i, j].IsAddedToGame == false | TileOwnership[i, j]. == true)
667                //{
668                //try
669                //{
670                //    Add(TileOwnership[i, j]);
671                //}
672                //catch
673                //{
674                //    //MessageDisplay.Add("TileOwnership not added at " + i + "; " + j + " ;; because of an exception.");
675                //}
676                //}
677            }
678            //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
679        }
680
681        //private void DrawUnit(int i, int j)
682        //{
683        //    if (UnitTile[i, j].IsAddedToGame == false)
684        //    {
685        //        Add(UnitTile[i, j]);
686        //        //Mouse.ListenOn(UnitTile[i, j], MouseButton.Left, Jypeli.ButtonState.Pressed, UnitSelect, "Valitse yksikkö painamalla ruutua", i, j);
687        //    }
688        //}
689
690        private void RemoveOwnership(int i, int j)
691        {
692            OwnershipMap[i, j] = -1;
693            TileOwnership[i, j].Destroy();
694        }
695
696        private void AddStartingCity(int playernumber, int i, int j)
697        {
698            //MessageBox.Show(TileOwnership[i, j].X + "x" + TileOwnership[i, j].Y + " " + DTile[i, j].X + "x" + DTile[i, j].Y + " Params: " + i + " " + j);
699            Rules.pCivs[playernumber].Production = Rules.pCivs[playernumber].Production + 10;
700            Rules.pCivs[playernumber].CityCoords[Rules.pCivs[playernumber].NumberofCities, 0] = i;
701            Rules.pCivs[playernumber].CityCoords[Rules.pCivs[playernumber].NumberofCities, 1] = j;
702            Rules.pCivs[playernumber].NumberofCities = Rules.pCivs[playernumber].NumberofCities + 1;
703            //MessageBox.Show("AddStartingCity: " + i + " " + j + " Playernumber: " + playernumber + "CityCoords: " + Rules.pCivs[playernumber].CityCoords[0, 0] + " " + Rules.pCivs[playernumber].CityCoords[0, 1]);
704            if (Rules.pCivs[playernumber].HumanPlayer == false)
705            {
706                Rules.pCivs[playernumber].Color = setAIOwnershipColor(playernumber);
707                Rules.pCivs[playernumber].Enabled = true;
708                Rules.pCivs[playernumber].Name = Rules.pCivs[playernumber].Color + " " + "Empire";
709            }
710            else
711            {
712                CheckAndRemoveShroud_FromPos(i, j);
713            }
714            OwnershipMap[i, j] = playernumber;
715            // 16. 6. 2010: Kutsutaanpa DrawOwnership sittenkin vasta kaupungin piirtämisen jälkeen (ks. InitMap ja DTilen asettaminen)
716            //DrawOwnership(i, j);
717
718            //DTile[i, j].Image = LoadImage("\\Content\\Textures\\cityancient");
719        }
720
721        // Aliohjelma yksikön luomiseen
722        private void CreateUnit(int i, int j, ALTKUnits.UnitClass unittype, int civnumber)
723        {
724            //MessageBox.Show(i + " " + j);
725            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits] = new BaseRules.Unit();
726            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].HP = 1.00;
727            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosY = i;
728            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosX = j;
729            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].UnitType = unittype;
730            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].CurrentMovementPoints = unittype.Movement;
731            Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits + 1;
732            UnitMap[i, j] = civnumber;
733
734            UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTile");
735
736            if (OwnershipMap[i, j] == -1)
737            {
738            }
739            else
740            {
741                OwnershipMap[i, j] = civnumber;
742                DrawOwnership(i, j);
743            }
744        }
745
746        private void AICreateUnit(int i, int j, ALTKUnits.UnitClass unittype, int civnumber, int path)
747        {
748            //MessageBox.Show(i + " " + j + " " + "Path: " + path);
749            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits] = new BaseRules.Unit();
750            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].HP = 1.00;
751            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosY = i;
752            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].PosX = j;
753            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].UnitType = unittype;
754            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].CurrentMovementPoints = unittype.Movement;
755            Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits].AIPathfindingRoute = path;
756            Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits + 1;
757            UnitMap[i, j] = civnumber;
758
759            UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTile");
760
761            if (OwnershipMap[i, j] == -1)
762            {
763            }
764            else
765            {
766                OwnershipMap[i, j] = civnumber;
767                DrawOwnership(i, j);
768            }
769        }
770
771        public string GetUnits_FromPositionForView(int i, int j)
772        {
773            //MessageBox.Show("GetUnits...");
774            string units = "";
775            int civid;
776            civid = OwnershipMap[i, j];
777            //int[] UnitAmount = new int[23];
778            //MessageBox.Show("GetUnits... Stage 0.5");
779            //for (int c = 0; c <= 23; c++)
780            //{
781                //MessageBox.Show("GetUnits... Stage 0.8");
782                //UnitAmount[c] = new int();
783            //}
784            //MessageBox.Show("GetUnits... Stage 1");
785            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
786            {
787                //MessageBox.Show("GetUnits... Stage 2");
788                if (Rules.pCivs[civid].Units[a].PosY == i && Rules.pCivs[civid].Units[a].PosX == j) // && (units.Contains(Rules.pCivs[civid].Units[a].UnitType.Name)))
789                {
790                    //MessageBox.Show("ffff");
791                    // UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] = UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] + 1;
792                    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 + " : " + 
793                        Rules.pCivs[civid].Units[a].UnitType.Movement + " : " + Rules.pCivs[civid].Units[a].UnitType.Description + Environment.NewLine;
794                        //UnitAmount[Rules.pCivs[civid].Units[a].UnitType.UnitId] = Rules.pCivs[civid].Units[a].UnitType.UnitId + 1;
795                }
796            }
797            return units;
798            //}
799            //return units;
800            //MessageBox.Show(units);
801            //MessageBox.Show("GetUnits... Stage 5");
802            //for (int b = 0; b <= 23; b++)
803            //{
804            //    if (UnitAmount[b] > 0)
805            //    {
806            //        // MessageBox.Show("GetUnits... Stage 6");
807            //        if (UnitAmount[b] > 1)
808            //        {
809            //            //MessageBox.Show("GetUnits... Stage 7");
810            //            units = units + BaseRules.Rules.getUnit_FromId(UnitAmount[b]).Name + " x" + UnitAmount[b] + Environment.NewLine;
811            //            return units;
812            //        }
813            //        else if (UnitAmount[b] == 1)
814            //        {
815            //             // MessageBox.Show("GetUnits... Stage 8");
816            //            units = units + BaseRules.Rules.getUnit_FromId(UnitAmount[b]).Name + Environment.NewLine;
817            //            return units;
818            //        }
819            //    }
820            //}
821            //return units;
822            //    //MessageBox.Show("GetUnits... Stage 9");
823
824           // MessageBox.Show("GetUnits... Stage 10");
825        }
826
827        public int GetUnit_FromPositionForSelection(int i, int j)
828        {
829            int civid;
830            civid = OwnershipMap[i, j];
831            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
832            {
833                if (Rules.pCivs[civid].Units[a].PosY == i && Rules.pCivs[civid].Units[a].PosX == j)
834                {
835                    return a;
836                }
837            }
838            return -1;
839        }
840
841        public int GetUnit_FromPositionForRemoval(int i, int j, ALTKUnits.UnitClass unittype, double unitHP)
842        {
843           // MessageBox.Show("GetUnit_FromPosition: " + i + " " + j);
844            int civid;
845            civid = OwnershipMap[i, j];
846            for (int a = 0; a <= Rules.pCivs[civid].NumberofUnits - 1; a++)
847            {
848                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)
849                {
850                    return a;
851                }
852            }
853            return -1;
854        }
855
856        private void RemoveUnit(int i, int j, int civnumber, ALTKUnits.UnitClass unittype, double unitHP)
857        {
858            //MessageBox.Show(i + " " + j + " " + civnumber);
859            int unitpos = GetUnit_FromPositionForRemoval(i, j, unittype, unitHP);
860            if (unitpos > 0 && Rules.pCivs[civnumber].NumberofUnits > 2)
861            {
862                //MessageBox.Show("FirstMethod");
863                for (int a = unitpos + 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
864                {
865                    Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
866                    Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
867                    Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
868                    Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
869                }
870                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
871                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
872                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
873                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
874            }
875            else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits > 1)
876            {
877                //MessageBox.Show("SecondMethod");
878                for (int a = 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
879                {
880                    Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
881                    Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
882                    Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
883                    Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
884                }
885                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
886                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
887                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
888                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
889            }
890            else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits == 1)
891            {
892                //MessageBox.Show("ThirdMethod");
893                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
894                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
895                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
896                Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
897            }
898            Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits - 1;
899        }
900
901        public string setAIOwnershipColor(int playernumber)
902        {
903            int c;
904            int b;
905            bool ColorInUse = false;
906            for (b = 0; b <= 20; b++)
907            {
908                ColorInUse = false;
909                for (c = 0; c <= 30; c++)
910                {
911                    if (Rules.pCivs[c].Color == getOwnershipColor_fromInt(b))
912                    {
913                        ColorInUse = true;
914                    }
915                }
916                if (ColorInUse == false)
917                {
918                    return getOwnershipColor_fromInt(b);
919                }
920            }
921            return getOwnershipColor_fromInt(0);
922        }
923
924        public string getOwnershipColor_fromInt(Int32 color)
925        {
926            if (color == 0) { return "Aqua"; }
927            if (color == 1) { return "Black"; }
928            if (color == 2) { return "Limegreen"; }
929            if (color == 3) { return "Orange"; }
930            if (color == 4) { return "Beige"; }
931            if (color == 5) { return "Red"; }
932            if (color == 6) { return "Rustred"; }
933            if (color == 7) { return "Yellow"; }
934            if (color == 8) { return "Blue"; }
935            if (color == 9) { return "Darkblue"; }
936            if (color == 10) { return "Darkgreen"; }
937            if (color == 11) { return "Lightblue"; }
938            if (color == 12) { return "Purple"; }
939            if (color == 13) { return "Darkpurple"; }
940            if (color == 14) { return "Lightpurple"; }
941            if (color == 15) { return "Gold"; }
942            if (color == 16) { return "Silver"; }
943            if (color == 17) { return "Pink"; }
944            if (color == 18) { return "Teal"; }
945            if (color == 19) { return "Greenyellow"; }
946            if (color == 20) { return "Darkorange"; }
947            if (color == 21) { return "White"; }
948            if (color == 22) { return "Darkgray"; }
949            return "Aqua";
950        }
951
952        string getTexture_fromTerrainType(int terraintype, int terrainlayer, int i, int j)
953        {
954            if (terrainlayer == 0)
955            {
956                if (terraintype == Lehtimetsa) { return Application.StartupPath + "\\Content\\Textures\\grassland"; }
957                if (terraintype == Vuoristo) { return Application.StartupPath + "\\Content\\Textures\\mountain"; }
958                if (terraintype == Aavikko) { return Application.StartupPath + "\\Content\\Textures\\desert"; }
959                if (terraintype == Tundra) { return Application.StartupPath + "\\Content\\Textures\\tundra"; }
960            }
961            else if (terrainlayer == 1)
962            {
963                if (terraintype == Tyhja) { return Application.StartupPath + "\\Content\\Textures\\nothing"; }
964                if (terraintype == Vuoristo) { return Application.StartupPath + "\\Content\\Textures\\mountain"; }
965                if (terraintype == Havumetsa) { return Application.StartupPath + "\\Content\\Textures\\forest"; }
966                if (terraintype == Kuusimetsa)
967                {
968                    if (TerrainMap[i, j] == 3)
969                    {
970                        return Application.StartupPath + "\\Content\\Textures\\spruceforestS";
971                    }
972                    else
973                    {
974                        return Application.StartupPath + "\\Content\\Textures\\spruceforest";
975                    }
976                }
977                // Jos terraintype on 10 tai enemmän, ruudussa on pelaajan kaupunki (ks. getTerrainType)
978                if (terraintype >= 10)
979                {
980                    if (TerrainMap[i, j] == Tundra)
981                    {
982                        return Application.StartupPath + "\\Content\\Textures\\cityancientTundra";
983                        //DrawOwnership(i, j);
984                    }
985                    else
986                    {
987                        return Application.StartupPath + "\\Content\\Textures\\cityancient";
988                    }
989                }
990                return Application.StartupPath + "\\Content\\Textures\\nothing";
991            }
992            return Application.StartupPath + "\\Content\\Textures\\grassland.jpg";
993        }
994        # endregion
995
996        private void InitGUI()
997        {
998            TileDisp = new TextDisplay();
999            TileDisp.X = Screen.Left + 120;
1000            TileDisp.Y = Screen.Bottom + 200;
1001            TileDisp.TextColor = Color.White;
1002
1003            UnitStatsDisp = new TextDisplay();
1004            UnitStatsDisp.X = Screen.Left + 400;
1005            UnitStatsDisp.Y = Screen.Bottom + 400;
1006            UnitStatsDisp.Text = "d23";
1007            UnitStatsDisp.TextColor = Color.DarkRed;
1008
1009            ProductionDisp = new TextDisplay();
1010            ProductionDisp.X = Screen.Right - 150;
1011            ProductionDisp.Y = Screen.Top - 50;
1012            ProductionDisp.Text = "Tuotanto: 10/120";
1013            ProductionDisp.TextColor = Color.Wheat;
1014
1015            BuildCityDisp = new TextDisplay();
1016            BuildCityDisp.X = Screen.Right - 200;
1017            BuildCityDisp.Y = Screen.Top - 150;
1018            BuildCityDisp.TextColor = Color.Green;
1019            BuildCityDisp.Text = "Rakenna kaupunki";
1020
1021            //Mouse.ListenOn(BuildCityDisp, MouseButton.Left, Jypeli.ButtonState.Pressed, BuildCityClicked, "Rakenna kaupunki");
1022            Keyboard.Listen(Key.B, Jypeli.ButtonState.Pressed, BuildCityClicked, "Rakenna kaupunki");
1023
1024            BuildUnitsDisp = new TextDisplay();
1025            BuildUnitsDisp.X = Screen.Right - 120;
1026            BuildUnitsDisp.Y = Screen.Top - 200;
1027            BuildUnitsDisp.TextColor = Color.Green;
1028            BuildUnitsDisp.Text = "Rakenna yksiköitä (U)";
1029
1030            Keyboard.Listen(Key.U, Jypeli.ButtonState.Pressed, BuildUnitsClicked, "Näytä yksikkövalikko");
1031
1032            Unit1Disp = new TextDisplay();
1033            Unit1Disp.X = Screen.Right - 150;
1034            Unit1Disp.Y = Screen.Top - 250;
1035            Unit1Disp.TextColor = Color.DarkGreen;
1036            Unit1Disp.Text = "";
1037
1038            Keyboard.Listen(Key.D1, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 1. puun yksikkö", 1);
1039
1040            Unit2Disp = new TextDisplay();
1041            Unit2Disp.X = Screen.Right - 150;
1042            Unit2Disp.Y = Screen.Top - 300;
1043            Unit2Disp.TextColor = Color.DarkGreen;
1044            Unit2Disp.Text = "";
1045
1046            Keyboard.Listen(Key.D2, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 2. puun yksikkö", 2);
1047
1048            Unit3Disp = new TextDisplay();
1049            Unit3Disp.X = Screen.Right - 150;
1050            Unit3Disp.Y = Screen.Top - 350;
1051            Unit3Disp.TextColor = Color.DarkGreen;
1052            Unit3Disp.Text = "";
1053
1054            Keyboard.Listen(Key.D3, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 3. puun yksikkö", 3);
1055
1056            Unit4Disp = new TextDisplay();
1057            Unit4Disp.X = Screen.Right - 150;
1058            Unit4Disp.Y = Screen.Top - 400;
1059            Unit4Disp.TextColor = Color.DarkGreen;
1060            Unit4Disp.Text = "";
1061
1062            Keyboard.Listen(Key.D4, Jypeli.ButtonState.Pressed, BuildUnit, "Rakenna 4. puun yksikkö", 4);
1063
1064            ResearchDisp = new TextDisplay();
1065            ResearchDisp.X = Screen.Right - 200;
1066            ResearchDisp.Y = Screen.Top - 500;
1067            ResearchDisp.TextColor = Color.Green;
1068            ResearchDisp.Text = "Teknologia:" + Environment.NewLine + "Horseback Riding 199/200";
1069
1070            ResearchableTech1 = new TextDisplay();
1071            ResearchableTech2 = new TextDisplay();
1072            ResearchableTech3 = new TextDisplay();
1073
1074            ClicktoResearch = new TextDisplay();
1075            ClicktoResearch.X = Screen.Right - 200;
1076            ClicktoResearch.Y = Screen.Top - 600;
1077            ClicktoResearch.TextColor = Color.Green;
1078            ClicktoResearch.Text = "Kehitä teknologiaa";
1079
1080            MessageDisplay.TextColor = Color.Orange;
1081
1082            Add(TileDisp);
1083            Add(UnitStatsDisp);
1084            Add(ProductionDisp);
1085            Add(BuildCityDisp);
1086            Add(BuildUnitsDisp);
1087            Add(Unit1Disp);
1088            Add(Unit2Disp);
1089            Add(Unit3Disp);
1090            Add(Unit4Disp);
1091            //Add(ResearchDisp);
1092            //Add(ClicktoResearch);
1093        }
1094
1095        private void BuildUnit(int unittree)
1096        {
1097            if (UnitBuildingMode == true)
1098            {
1099                int UnitCost = new int();
1100                if (unittree == 1)
1101                {
1102                    UnitCost = 20;
1103                }
1104                else if (unittree == 2)
1105                {
1106                    UnitCost = 30;
1107                }
1108                else if (unittree == 3)
1109                {
1110                    UnitCost = 30;
1111                }
1112                else if (unittree == 4)
1113                {
1114                    UnitCost = 40;
1115                }
1116
1117                if (UnitCost > CurrProduction)
1118                {
1119                    MessageDisplay.Add("Sinulla ei ole tarpeeksi tuotantoa yksikön rakentamiseen.");
1120                }
1121                else
1122                {
1123                    CurrProduction = CurrProduction - UnitCost;
1124                    ChangeProductionDispText();
1125                    MessageDisplay.Add("Rakensit yksikön " + GetBuildableUnit(unittree).Name + ". Valitse kaupunki, mihin yksikkö rakennetaan.");
1126                    currentunit = GetBuildableUnit(unittree).UnitId;
1127                    UnitPositioningMode = true;
1128                }
1129            }
1130            else
1131            {
1132                MessageDisplay.Add("Et ole yksikönrakennustilassa.");
1133            }
1134        }
1135
1136        private ALTKUnits.UnitClass GetBuildableUnit(int unittree)
1137        {
1138            if (unittree == 1)
1139            {
1140                return BaseRules.Rules.Warrior;
1141            }
1142            if (unittree == 2)
1143            {
1144                return BaseRules.Rules.Archer;
1145            }
1146            if (unittree == 3)
1147            {
1148                return BaseRules.Rules.Spearman;
1149            }
1150            if (unittree == 4)
1151            {
1152                return BaseRules.Rules.Horseman;
1153            }
1154            return BaseRules.Rules.Warrior;
1155        }
1156
1157        private void BuildUnitsClicked()
1158        {
1159            if (UnitPositioningMode == true)
1160            {
1161                MessageDisplay.Add("Määritä aikaisemmalle yksikölle rakennussijainti.");
1162            }
1163
1164            if (UnitBuildingMode == true)
1165            {
1166                Unit1Disp.Text = "";
1167                Unit2Disp.Text = "";
1168                Unit3Disp.Text = "";
1169                Unit4Disp.Text = "";
1170                UnitBuildingMode = false;
1171            }
1172            else
1173            {
1174                UnitBuildingMode = true;
1175
1176                // Muutetaan tekstit
1177                SetUnitDispText(1);
1178                SetUnitDispText(2);
1179                SetUnitDispText(3);
1180                SetUnitDispText(4);
1181            }
1182        }
1183
1184        private void SetUnitDispText(int unitdisp)
1185        {
1186            if (unitdisp == 1)
1187            {
1188                Unit1Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T1Units[0]).Name + " [1] (20)";
1189            }
1190            else if (unitdisp == 2)
1191            {
1192                Unit2Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T2Units[0]).Name + " [2] (30)";
1193            }
1194            else if (unitdisp == 3)
1195            {
1196                Unit3Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T3Units[0]).Name + " [3] (30)";
1197            }
1198            else if (unitdisp == 4)
1199            {
1200                Unit4Disp.Text = "Rakenna " + BaseRules.Rules.getUnit_FromId(BaseRules.Rules.T4Units[0]).Name + " [4] (40)";
1201            }
1202        }
1203
1204        private void BuildCityClicked()
1205        {
1206            TileClickAllowed = false;
1207            if (CityPlaceSelection == false)
1208            {
1209                Rules.pCivs[CurrentPlayer].BuiltFromCity = Rules.pCivs[CurrentPlayer].BuiltFromCity + CurrProduction;
1210                CurrProduction = 0;
1211                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
1212                ChangeProductionDispText();
1213                if (Rules.pCivs[CurrentPlayer].BuiltFromCity > Rules.pCivs[CurrentPlayer].Production | Rules.pCivs[CurrentPlayer].BuiltFromCity == Rules.pCivs[CurrentPlayer].Production)
1214                {
1215                    CurrProduction = Rules.pCivs[CurrentPlayer].BuiltFromCity - Rules.pCivs[CurrentPlayer].Production;
1216                    MessageDisplay.Add("Sait kaupungin valmiiksi; valitse uuden kaupungin sijainti.");
1217                    BuildCityDisp.Text = "Peruuta kaupungin rakentaminen (B) (" + Rules.pCivs[CurrentPlayer].Production / 2 + ")";
1218                    BuildCityDisp.TextColor = Color.Red;
1219                    BuildCityDisp.X = BuildCityDisp.X - 20;
1220                    ChangeProductionDispText();
1221                    CityPlaceSelection = true;
1222                }
1223            }
1224            else
1225            {
1226                BuildCityDisp.TextColor = Color.Green;
1227                BuildCityDisp.X = BuildCityDisp.X + 20;
1228                Rules.pCivs[CurrentPlayer].BuiltFromCity = 0;
1229                BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
1230                CityPlaceSelection = false;
1231                CurrProduction = CurrProduction + (Rules.pCivs[CurrentPlayer].Production / 2);
1232                ChangeProductionDispText();
1233            }
1234            TileClickAllowed = true;
1235        }
1236
1237        private void ChangeProductionDispText()
1238        {
1239            ProductionDisp.Text = "Vuoro: " + TurnNumber + Environment.NewLine +
1240                "Tuotantoa vuorossa: " + Rules.pCivs[CurrentPlayer].Production + Environment.NewLine +
1241                "Tuotantoa jäljellä: " + CurrProduction;
1242        }
1243
1244        private void InitRules()
1245        {
1246            // Käytetään valmiiksi tehtyjä DLL-tiedostoja
1247            BaseRules.Rules.InitTechs();
1248            BaseRules.Rules.InitUnits();
1249            BaseRules.Rules.InitDifficulty();
1250            BaseRules.Rules.InitCivs();
1251            BaseRules.Rules.InitAIBehaviour();
1252        }
1253
1254        private void RemoveShroud(int i, int j)
1255        {
1256            try
1257            {
1258                ShroudMap[i, j] = 0;
1259                ShroudTile[i, j].Destroy();
1260                try
1261                {
1262                    if (OwnershipMap[i, j] > -1)
1263                    {
1264                        DrawOwnership(i, j);
1265                    }
1266                }
1267                catch
1268                {
1269                }
1270            }
1271            catch
1272            {
1273                MessageDisplay.Add("Shroud not removed from tile " + i + "; " + j + " because of IndexoutofRange exception.");
1274            }
1275        }
1276
1277        private void CheckAndRemoveShroud_FromPos(int i, int j)
1278        {
1279            RemoveShroud(i, j);
1280            for (int shri = i - 2; shri <= i + 2; shri++)
1281            {
1282                for (int shrj = j - 2; shrj <= j + 2; shrj++)
1283                {
1284                    RemoveShroud(shri, shrj);
1285                }
1286            }
1287        }
1288
1289        public int AI_GetNextDirection(int PathRoute, int PathNumber)
1290        {
1291            return AIPaths[PathRoute - 1, PathNumber + 1];
1292        }
1293
1294        private void TurnSystem_PlayAITurn(int playernumber)
1295        {
1296            //DisableInput();
1297            int AIProduction = new int();
1298            double AIProduction2 = new double();
1299            AIProduction = Rules.pCivs[playernumber].Production;
1300            AIProduction2 = Rules.GetDifficulty_FromInt(currDiffLevel).ComputerProductionBonus * AIProduction;
1301            CurrProduction = Convert.ToInt32(AIProduction2);
1302            if (TurnNumber == 1)
1303            {
1304                AICapitalCoordY = Rules.pCivs[playernumber].CityCoords[1, 0];
1305                AICapitalCoordX = Rules.pCivs[playernumber].CityCoords[1, 1];
1306                Rules.pCivs[playernumber].Behaviour = Rules.Rusher;
1307                for (int a = 0; a <= Rules.pCivs[playernumber].NumberofCities - 1; a++)
1308                {
1309                    for (int b = 0; b <= 4 + currDiffLevel; b++)
1310                    {
1311                        CreateUnit(Rules.pCivs[playernumber].CityCoords[a, 0], Rules.pCivs[playernumber].CityCoords[a, 1], Rules.Archer, playernumber);
1312                    }
1313                }
1314            }
1315            int path = new int();
1316            path = RandomGen.NextInt(1, 2);
1317            for (int hproduction = 0; hproduction <= (CurrProduction / 40); hproduction++)
1318            {
1319                //MessageBox.Show(Convert.ToString(path));
1320                AICreateUnit(Rules.pCivs[playernumber].CityCoords[1, 0], Rules.pCivs[playernumber].CityCoords[1, 1], Rules.Horseman, playernumber, path);
1321            }
1322
1323            for (int a = 0; a < Rules.pCivs[playernumber].NumberofUnits; a++)
1324            {
1325                Rules.pCivs[playernumber].Units[a].CurrentMovementPoints = Rules.pCivs[playernumber].Units[a].UnitType.Movement;
1326                Rules.pCivs[playernumber].Units[a].HP = 1.00;
1327
1328                if (Rules.pCivs[playernumber].Units[a].AIPathfindingRoute == 1)
1329                {
1330                    //MessageBox.Show("AIPathfindingRoute == 1");
1331                    AISelectedUnit = a;
1332                    AIMoveUnit(AI_GetNextDirection(Rules.pCivs[playernumber].Units[a].AIPathfindingRoute, Rules.pCivs[playernumber].Units[a].AIPathfindingNumber));
1333                    if (Rules.pCivs[playernumber].Units[a].CurrentMovementPoints > 0)
1334                    {
1335                        AIMoveUnit(AI_GetNextDirection(Rules.pCivs[playernumber].Units[a].AIPathfindingRoute, Rules.pCivs[playernumber].Units[a].AIPathfindingNumber));
1336                    }
1337                }
1338
1339                if (Rules.pCivs[playernumber].Units[a].AIPathfindingRoute == 2)
1340                {
1341                    //MessageBox.Show("AIPathfindingRoute == 2");
1342                    AISelectedUnit = a;
1343                    AIMoveUnit(AI_GetNextDirection(Rules.pCivs[playernumber].Units[a].AIPathfindingRoute, Rules.pCivs[playernumber].Units[a].AIPathfindingNumber));
1344                    if (Rules.pCivs[playernumber].Units[a].CurrentMovementPoints > 0)
1345                    {
1346                        AIMoveUnit(AI_GetNextDirection(Rules.pCivs[playernumber].Units[a].AIPathfindingRoute, Rules.pCivs[playernumber].Units[a].AIPathfindingNumber));
1347                    }
1348                }
1349            }
1350
1351            //MessageBox.Show(Convert.ToString(CurrProduction));
1352            EnableInput();
1353            EndTurn();
1354        }
1355
1356        private void TurnSystem_Start(int playernumber)
1357        {
1358            if (Rules.pCivs[playernumber].HumanPlayer == false)
1359            {
1360                TurnSystem_PlayAITurn(playernumber);
1361                return;
1362            }
1363            TurnNumber = TurnNumber + 1;
1364            MessageDisplay.Add("Vuorosi on alkanut!");
1365            CurrentPlayer = playernumber;
1366            CurrProduction = Rules.pCivs[playernumber].Production;
1367            ProductionDisp.Text = "Vuoro: " + TurnNumber + Environment.NewLine +
1368                "Tuotantoa vuorossa: " + Rules.pCivs[playernumber].Production + Environment.NewLine +
1369                "Tuotantoa jäljellä: " + CurrProduction;
1370            BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[playernumber].BuiltFromCity + " / " + Rules.pCivs[playernumber].Production + ")";
1371            if (TurnNumber == 1)
1372            {
1373                PlayerCapitalCoordY = Rules.pCivs[playernumber].CityCoords[0, 0];
1374                PlayerCapitalCoordX = Rules.pCivs[playernumber].CityCoords[0, 1];
1375                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Crossbowman, playernumber);
1376                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Archer, playernumber);
1377                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Knight, playernumber);
1378                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Knight, playernumber);
1379                CreateUnit(Rules.pCivs[playernumber].CityCoords[0, 0], Rules.pCivs[playernumber].CityCoords[0, 1], Rules.Rifleman, playernumber);
1380                //RemoveUnit(Rules.pCivs[playernumber].Units[0].PosY, Rules.pCivs[playernumber].Units[0].PosX, playernumber);
1381            }
1382            for (int a = 0; a < Rules.pCivs[playernumber].NumberofUnits; a++)
1383            {
1384                Rules.pCivs[playernumber].Units[a].CurrentMovementPoints = Rules.pCivs[playernumber].Units[a].UnitType.Movement;
1385                Rules.pCivs[playernumber].Units[a].HP = 1.00;
1386            }
1387            if (Rules.pCivs[1].Enabled == false)
1388            {
1389                MessageDisplay.Add("You are victorious!");
1390            }
1391        }
1392
1393        protected override void Update(Time time)
1394        {
1395            base.Update(time);
1396            // Mouse.PositionOnScreen voisi olla vain positiivinen, eikä ruudun pitäisi jakautua keskeltä kahtia
1397            // negatiivisiin ja positiivisiin kokonaislukuihin
1398
1399            if (gamestarted == true)
1400            {
1401                for (int i = 0; i <= (kartanKorkeus - 1); i++)
1402                {
1403                    for (int j = 0; j <= (kartanLeveys - 1); j++)
1404                    {
1405                        if (Mouse.IsCursorOnGameObject(tile[i, j]))
1406                        {
1407                            TileDisp.Text = getTileInfo_forTileDisp(i, j);
1408                            if (UnitsSelected == false)
1409                            {
1410                                UnitStatsDisp.Text = getUnitDisp(i, j, 0);
1411                            }
1412                            //Application.DoEvents();
1413                        }
1414                        //Mouse.ListenMovement(tile[i, j], showTileInfo_forTileDisp, null, i, j);
1415                        // MessageBox.Show(Convert.ToString(TerrainMap[i, j]));
1416                    }
1417                }
1418                //TileDisp.Text = getTileInfo_forTileDisp(Convert.ToInt32(Mouse.PositionOnWorld.X) / -48, Convert.ToInt32(Mouse.PositionOnWorld.Y) / 48);
1419            if (Mouse.PositionOnScreen.X > MouseScreenWidth) { MoveCamera(0); }
1420            else if (Mouse.PositionOnScreen.X < NegMouseScreenWidth) { MoveCamera(2); }
1421            else if (Mouse.PositionOnScreen.Y > MouseScreenHeight) { MoveCamera(1); }
1422            else if (Mouse.PositionOnScreen.Y < NegMouseScreenHeight) { MoveCamera(3); }
1423            }
1424        }
1425
1426        public string getTileInfo_forTileDisp(int i, int j)
1427        {
1428            // Haetaan tiedot ruudulle
1429            string tileinfo;
1430            int Defensebonus = new int();
1431            tileinfo = i + "; " + j + " :" + Environment.NewLine;
1432            //MessageBox.Show(i + " " + j);
1433            // Maaston perustiedot
1434            if (TerrainMap[i, j] == 0)
1435            {
1436                tileinfo = tileinfo + "Ruohotasankoa";
1437            }
1438            else if (TerrainMap[i, j] == 1)
1439            {
1440                tileinfo = tileinfo + "Vuoristoa";
1441            }
1442            else if (TerrainMap[i, j] == 2)
1443            {
1444                tileinfo = tileinfo + "Aavikkoa";
1445                Defensebonus = Defensebonus - 25;
1446            }
1447            else if (TerrainMap[i, j] == 3)
1448            {
1449                tileinfo = tileinfo + "Tundraa";
1450                Defensebonus = Defensebonus + 10;
1451            }
1452
1453            // Erikoismaaston tiedot
1454
1455            if (DTerrainMap[i, j] == 0)
1456            {
1457            }
1458            else if (DTerrainMap[i, j] == 1)
1459            {
1460                tileinfo = tileinfo + Environment.NewLine + "Vuoristoa" + Environment.NewLine + "Läpipääsemätön";
1461            }
1462            else if (DTerrainMap[i, j] == 2)
1463            {
1464                tileinfo = tileinfo + Environment.NewLine + "Lehtimetsää";
1465                Defensebonus = Defensebonus + 10;
1466            }
1467            else if (DTerrainMap[i, j] == 3)
1468            {
1469                tileinfo = tileinfo + Environment.NewLine + "Kuusimetsää";
1470                Defensebonus = Defensebonus + 25;
1471            }
1472            else
1473            {
1474                // MessageBox.Show(Convert.ToString(ShroudMap[i, j]));
1475                if (ShroudMap[i, j] == 0)
1476                {
1477                    try
1478                    {
1479                        if (OwnershipMap[i, j] >= -1)
1480                        {
1481                            tileinfo = tileinfo + Environment.NewLine + "Kaupunki";
1482                        }
1483                    }
1484                    catch
1485                    {
1486                    }
1487                }
1488            }
1489
1490            if (ShroudMap[i, j] == 0)
1491            {
1492                try
1493                {
1494                    if (OwnershipMap[i, j] > -1)
1495                    {
1496                        tileinfo = tileinfo + Environment.NewLine + Rules.pCivs[OwnershipMap[i, j]].Name;
1497                    }
1498                }
1499                catch
1500                {
1501                }
1502
1503                if (Defensebonus != 0)
1504                {
1505                    return tileinfo = tileinfo + Environment.NewLine + "Puolustusbonus: " + Defensebonus + "%";
1506                }
1507                else
1508                {
1509                    return tileinfo;
1510                }
1511            }
1512            return tileinfo;
1513        }
1514
1515        public string getUnitDisp(int i, int j, int s)
1516        {
1517            string unitinfo = "";
1518            if (ShroudMap[i, j] == 0)
1519            {
1520                try
1521                {
1522                    if (OwnershipMap[i, j] > -1)
1523                    {
1524                        //MessageBox.Show("OwnershipMap passed:" + i + " " + j + " UnitMap: " + UnitMap[i, j]);
1525                        //MessageBox.Show(Convert.ToString(0 > -1));
1526                        if (UnitMap[i, j] > -1)
1527                        {
1528                            //MessageBox.Show("UnitMap passed:" + i + " " + j);
1529                            //string unitstats;
1530                            if (s == 0)
1531                            {
1532                                unitinfo = "Ruudun yksiköt: " + Environment.NewLine + GetUnits_FromPositionForView(i, j);
1533                            }
1534                            else if (s == 1)
1535                            {
1536                                unitinfo = "Valitut yksiköt: " + Environment.NewLine + GetUnits_FromPositionForView(i, j);
1537                            }
1538                        }
1539                    }
1540                }
1541                catch
1542                {
1543                }
1544            }
1545            return unitinfo;
1546        }
1547
1548        private void EndTurn()
1549        {
1550            if (Rules.pCivs[CurrentPlayer].HumanPlayer == true)
1551            {
1552                MessageDisplay.Add("Lopetit vuorosi..");
1553            }
1554            if (SelectedUnit > -1)
1555            {
1556                DeselectUnit();
1557            }
1558            if (CurrentPlayer == PlayerAmount - 1)
1559            {
1560                CurrentPlayer = CurrentPlayer - 1;
1561            }
1562            else
1563            {
1564                CurrentPlayer = CurrentPlayer + 1;
1565            }
1566
1567            if (OwnershipMap[PlayerCapitalCoordY, PlayerCapitalCoordX] != 0)
1568            {
1569                MessageDisplay.TextColor = Color.Red;
1570                MessageDisplay.Add("You've been defeated!");
1571                return;
1572            }
1573            if (TurnNumber != 1)
1574            {
1575                if (OwnershipMap[AICapitalCoordY, AICapitalCoordX] != 1)
1576                {
1577                    MessageDisplay.TextColor = Color.Green;
1578                    MessageDisplay.Add("You are victorious!");
1579                    return;
1580                }
1581            }
1582            AISelectedUnit = -1;
1583            TurnSystem_Start(CurrentPlayer);
1584        }
1585
1586        private void DisableInput()
1587        {
1588            Keyboard.Disable(Key.NumPad1);
1589            Keyboard.Disable(Key.NumPad2);
1590            Keyboard.Disable(Key.NumPad3);
1591            Keyboard.Disable(Key.NumPad4);
1592            Keyboard.Disable(Key.NumPad5);
1593            Keyboard.Disable(Key.NumPad6);
1594            Keyboard.Disable(Key.NumPad7);
1595            Keyboard.Disable(Key.NumPad8);
1596            Keyboard.Disable(Key.NumPad9);
1597
1598            Keyboard.Disable(Key.B);
1599            Keyboard.Disable(Key.U);
1600            Keyboard.Disable(Key.D1);
1601            Keyboard.Disable(Key.D2);
1602            Keyboard.Disable(Key.D3);
1603            Keyboard.Disable(Key.D4);
1604            Keyboard.Disable(Key.End);
1605            Keyboard.Disable(Key.Home);
1606
1607            Mouse.Disable(MouseButton.Left);
1608        }
1609
1610        private void EnableInput()
1611        {
1612            Keyboard.Enable(Key.NumPad1);
1613            Keyboard.Enable(Key.NumPad2);
1614            Keyboard.Enable(Key.NumPad3);
1615            Keyboard.Enable(Key.NumPad4);
1616            Keyboard.Enable(Key.NumPad5);
1617            Keyboard.Enable(Key.NumPad6);
1618            Keyboard.Enable(Key.NumPad7);
1619            Keyboard.Enable(Key.NumPad8);
1620            Keyboard.Enable(Key.NumPad9);
1621
1622            Keyboard.Enable(Key.B);
1623            Keyboard.Enable(Key.U);
1624            Keyboard.Enable(Key.D1);
1625            Keyboard.Enable(Key.D2);
1626            Keyboard.Enable(Key.D3);
1627            Keyboard.Enable(Key.D4);
1628            Keyboard.Enable(Key.End);
1629            Keyboard.Enable(Key.Home);
1630
1631            Mouse.Enable(MouseButton.Left);
1632        }
1633
1634        private void InitControls()
1635        {
1636            Keyboard.Listen(Key.Right, Jypeli.ButtonState.Down, MoveCamera, null, 0);
1637            Keyboard.Listen(Key.Left, Jypeli.ButtonState.Down, MoveCamera, null, 2);
1638            Keyboard.Listen(Key.Up, Jypeli.ButtonState.Down, MoveCamera, null, 1);
1639            Keyboard.Listen(Key.Down, Jypeli.ButtonState.Down, MoveCamera, null, 3);
1640            Keyboard.Listen(Key.Tab, Jypeli.ButtonState.Down, ActivateDebug, null, 0);
1641            Keyboard.Listen(Key.Enter, Jypeli.ButtonState.Pressed, EndTurn, null);
1642
1643            Keyboard.Listen(Key.NumPad1, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä lounaaseen.", 1);
1644            Keyboard.Listen(Key.NumPad2, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä etelään.", 2);
1645            Keyboard.Listen(Key.NumPad3, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä kaakkoon.", 3);
1646            Keyboard.Listen(Key.NumPad4, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä länteen.", 4);
1647            Keyboard.Listen(Key.NumPad5, Jypeli.ButtonState.Pressed, MoveUnit, "Hyppää yksikkö yli.", 5);
1648            Keyboard.Listen(Key.NumPad6, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä itään.", 6);
1649            Keyboard.Listen(Key.NumPad7, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä luoteeseen.", 7);
1650            Keyboard.Listen(Key.NumPad8, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä pohjoiseen.", 8);
1651            Keyboard.Listen(Key.NumPad9, Jypeli.ButtonState.Pressed, MoveUnit, "Liikuta yksikköä koilliseen.", 9);
1652            Keyboard.Listen(Key.End, Jypeli.ButtonState.Pressed, SelectUnits, "Valitsee yksiköitä.");
1653            Keyboard.Listen(Key.Home, Jypeli.ButtonState.Pressed, SelectNextUnit, "Valitsee seuraavan yksikön.");
1654            Keyboard.Listen(Key.Pause, Jypeli.ButtonState.Pressed, DeselectUnit, "Poistaa yksikön valinnan.");
1655
1656            //Keyboard.Disable(Key.NumPad1);
1657            //Keyboard.Disable(Key.NumPad2);
1658            //Keyboard.Disable(Key.NumPad3);
1659            //Keyboard.Disable(Key.NumPad4);
1660            //Keyboard.Disable(Key.NumPad5);
1661            //Keyboard.Disable(Key.NumPad6);
1662            //Keyboard.Disable(Key.NumPad7);
1663            //Keyboard.Disable(Key.NumPad8);
1664            //Keyboard.Disable(Key.NumPad9);
1665
1666            MouseScreenWidth = new int();
1667            MouseScreenWidth = Convert.ToInt32(Peli.Screen.Width / 2) - 5;
1668            MouseScreenHeight = new int();
1669            MouseScreenHeight = Convert.ToInt32(Peli.Screen.Height / 2) - 5;
1670            NegMouseScreenWidth = new int();
1671            NegMouseScreenWidth = Convert.ToInt32(Peli.Screen.Width / -2) + 5;
1672            NegMouseScreenHeight = new int();
1673            NegMouseScreenHeight = Convert.ToInt32(Peli.Screen.Height / -2) + 20;
1674        }
1675
1676        # region Combat
1677        public double CalculateAttackerStrength(int unit, int terraintype, int dterraintype, int civid, int i, int j)
1678        {
1679            double returnvalue = new double();
1680            double baseStrength = new double();
1681            double modifier = 1;
1682
1683            //MessageBox.Show(civid + " " + unit);
1684            baseStrength = Rules.pCivs[civid].Units[unit].UnitType.Strength;
1685
1686            if (Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.FirstStrikes > 0)
1687            {
1688                if (Rules.pCivs[civid].Units[unit].UnitType.FirstStrikes == 0 | Rules.pCivs[civid].Units[unit].UnitType.FSOnAttack == false)
1689                {
1690                    baseStrength = baseStrength - ((Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Strength / 4));
1691                }
1692            }
1693
1694            if (dterraintype > 9)
1695            {
1696               modifier = (modifier + Rules.pCivs[civid].Units[unit].UnitType.CityAttackBonus);
1697            }
1698
1699            returnvalue = ((baseStrength * modifier) * Rules.pCivs[civid].Units[unit].HP);
1700            //MessageBox.Show(Convert.ToString((baseStrength * modifier) + "returnvalue: " + (baseStrength * modifier * Rules.pCivs[civid].Units[unit].HP + " ;;;; " + returnvalue)));
1701
1702            return returnvalue;
1703        }
1704
1705        public double CalculateDefenderStrength(int unit, int terraintype, int dterraintype, int civid, int i, int j)
1706        {
1707            double returnvalue = new double();
1708            double baseStrength = new double();
1709            double modifier = 1.0;
1710
1711            baseStrength = Rules.pCivs[civid].Units[unit].UnitType.Strength;
1712
1713            //MessageBox.Show(Convert.ToString(baseStrength));
1714
1715            if (dterraintype > 9)
1716            {
1717                modifier = (modifier + (Rules.pCivs[civid].Units[unit].UnitType.CityDefenseBonus));
1718                if (Rules.pCivs[civid].Units[unit].UnitType.Name == "Archer" | Rules.pCivs[civid].Units[unit].UnitType.Name == "Crossbowman")
1719                {
1720                    modifier = modifier + 1.0;
1721                    //MessageBox.Show(Rules.pCivs[civid].Units[unit].UnitType.Name + " " + modifier);
1722                }
1723                //MessageBox.Show(Convert.ToString(Rules.pCivs[civid].Units[unit].UnitType.CityDefenseBonus + " " + civid + " " + unit + " " + Rules.pCivs[civid].Units[unit].UnitType.Name));
1724            }
1725            //MessageBox.Show(Convert.ToString(dterraintype));
1726
1727            if (dterraintype == Kuusimetsa)
1728            {
1729                modifier = (modifier + 0.25);
1730            }
1731            else if (dterraintype == Lehtimetsa)
1732            {
1733                modifier = (modifier + 0.1);
1734            }
1735
1736            if (TerrainMap[i, j] == Tundra)
1737            {
1738                modifier = (modifier + 0.1);
1739            }
1740            else if (TerrainMap[i, j] == Aavikko)
1741            {
1742                modifier = (modifier - 0.25);
1743            }
1744
1745            //MessageBox.Show(Convert.ToString(modifier));
1746
1747            returnvalue = ((baseStrength *  modifier) * Rules.pCivs[civid].Units[unit].HP);
1748           // MessageBox.Show(Convert.ToString((baseStrength * modifier) + "returnvalue: " + (baseStrength *  modifier * Rules.pCivs[civid].Units[unit].HP + " ;;;; " + returnvalue)));
1749
1750            return returnvalue;
1751        }
1752
1753        private void AIEnterCombat(int i, int j, int ab, int bb)
1754        {
1755            if (DTerrainMap[i, j] > 9)
1756            {
1757                if (UnitMap[i, j] > -1)
1758                {
1759                    double attackerStrength;
1760                    double defenderStrength;
1761                    int chances = new int();
1762                    attackerStrength = CalculateAttackerStrength(AISelectedUnit, TerrainMap[i, j], DTerrainMap[i, j], CurrentPlayer, i, j);
1763                    defenderStrength = CalculateDefenderStrength(GetUnit_FromPositionForSelection(i, j), TerrainMap[i, j], DTerrainMap[i, j], OwnershipMap[i, j], i, j);
1764                    //MessageBox.Show(attackerStrength + " " + defenderStrength);
1765                    chances = CountChances(attackerStrength, defenderStrength);
1766                    //MessageBox.Show("Chances: " + chances + " AttackerStrength: " + attackerStrength + " DefenderStrength: " + defenderStrength);
1767                    int WinNumber = RandomGen.NextInt(1, 100);
1768                    double dNumber = new double();
1769                    if (attackerStrength > defenderStrength)
1770                    {
1771                        //MessageBox.Show("attacker > defender" + " " +WinNumber + " " + chances);
1772                        if (chances < WinNumber)
1773                        {
1774                            MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on kuollut puolustautuessaan vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "ia vastaan kohteessa " + i + "; " + j + "!");
1775                            RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1776                            dNumber = ((WinNumber - chances));
1777                            dNumber = dNumber / 10;
1778                            dNumber = dNumber / 10;
1779                            //MessageBox.Show(Convert.ToString(dNumber));
1780                            //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP - dNumber;
1781                            //UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name +
1782                            //Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Strength + Environment.NewLine +
1783                            //"-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Movement + Environment.NewLine +
1784                            //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Description + Environment.NewLine +
1785                            //" HP: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP * 100 + "/100";
1786                            CombatEnabled = false;
1787                            CheckForUnits(i, j);
1788                        }
1789                        else
1790                        {
1791                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + " on kuollut hyökätessään vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "iin!");
1792                            RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].HP);
1793                            DeselectUnit();
1794                            dNumber = ((chances - WinNumber) / 100);
1795                            Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
1796                            CombatEnabled = false;
1797                            CheckForUnits(ab, bb);
1798                        }
1799                    }
1800                    else
1801                    {
1802                        //MessageBox.Show("defender > attacker" + " " + WinNumber + " " + chances);
1803                        if (chances > WinNumber)
1804                        {
1805                            MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on kuollut puolustautuessaan vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "ia vastaan kohteessa " + i + "; " + j + "!");
1806                            RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1807                            dNumber = ((WinNumber - chances));
1808                            dNumber = dNumber / 10;
1809                            dNumber = dNumber / 10;
1810                            //MessageBox.Show(Convert.ToString(dNumber));
1811                            //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP - dNumber;
1812                            //UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name +
1813                            //Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Strength + Environment.NewLine +
1814                            //"-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Movement + Environment.NewLine +
1815                            //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Description + Environment.NewLine +
1816                            //" HP: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP * 100 + "/100";
1817                            CombatEnabled = false;
1818                            CheckForUnits(i, j);
1819                        }
1820                        else
1821                        {
1822                            MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on tuhonnut vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "in puolustautuessaan kohteessa " + i + "; " + j + "!");
1823                            RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].HP);
1824                            DeselectUnit();
1825                            dNumber = ((chances - WinNumber) / 100);
1826                            Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
1827                            CombatEnabled = false;
1828                            CheckForUnits(ab, bb);
1829                        }
1830                    }
1831                }
1832                else
1833                {
1834                    CityCaptureAI(i, j, ab, bb);
1835                    UnitMap[i, j] = CurrentPlayer;
1836                    CombatEnabled = false;
1837                }
1838            }
1839            else
1840            {
1841                double attackerStrength;
1842                double defenderStrength;
1843                int chances = new int();
1844                attackerStrength = CalculateAttackerStrength(AISelectedUnit, TerrainMap[i, j], DTerrainMap[i, j], CurrentPlayer, i, j);
1845                defenderStrength = CalculateDefenderStrength(GetUnit_FromPositionForSelection(i, j), TerrainMap[i, j], DTerrainMap[i, j], OwnershipMap[i, j], i, j);
1846                //MessageBox.Show(attackerStrength + " " + defenderStrength);
1847                chances = CountChances(attackerStrength, defenderStrength);
1848                int WinNumber = RandomGen.NextInt(1, 100);
1849                double dNumber = new double();
1850                //MessageBox.Show(WinNumber + " " + chances);
1851                if (attackerStrength > defenderStrength)
1852                {
1853                    if (chances < WinNumber)
1854                    {
1855                        MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on kuollut puolustautuessaan vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "ia vastaan kohteessa " + i + "; " + j + "!");
1856                        RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1857                        dNumber = ((WinNumber - chances));
1858                        dNumber = dNumber / 10;
1859                        dNumber = dNumber / 10;
1860                        //MessageBox.Show(Convert.ToString(dNumber));
1861                        //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP - dNumber;
1862                        //UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name +
1863                        //Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Strength + Environment.NewLine +
1864                        //"-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Movement + Environment.NewLine +
1865                        //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Description + Environment.NewLine +
1866                        //" HP: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP * 100 + "/100";
1867                        CombatEnabled = false;
1868                        CheckForUnits(i, j);
1869                    }
1870                    else
1871                    {
1872                        MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on tuhonnut vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "in puolustautuessaan kohteessa " + i + "; " + j + "!");
1873                        RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].HP);
1874                        DeselectUnit();
1875                        dNumber = ((chances - WinNumber) / 100);
1876                        Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
1877                        CombatEnabled = false;
1878                        CheckForUnits(ab, bb);
1879                    }
1880                }
1881                else
1882                {
1883                    if (chances > WinNumber)
1884                    {
1885                        MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on kuollut puolustautuessaan vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "ia vastaan kohteessa " + i + "; " + j + "!");
1886                        RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1887                        dNumber = ((WinNumber - chances));
1888                        dNumber = dNumber / 10;
1889                        dNumber = dNumber / 10;
1890                        //MessageBox.Show(Convert.ToString(dNumber));
1891                        //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP - dNumber;
1892                        //UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name +
1893                        //Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Strength + Environment.NewLine +
1894                        //"-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Movement + Environment.NewLine +
1895                        //Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Description + Environment.NewLine +
1896                        //" HP: " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].HP * 100 + "/100";
1897                        CombatEnabled = false;
1898                        CheckForUnits(i, j);
1899                    }
1900                    else
1901                    {
1902                        MessageDisplay.Add("Sinun " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + " on tuhonnut vihollisen " + Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].UnitType.Name + "in puolustautuessaan kohteessa " + i + "; " + j + "!");
1903                        RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[AISelectedUnit].HP);
1904                        DeselectUnit();
1905                        dNumber = ((chances - WinNumber) / 100);
1906                        Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
1907                        CombatEnabled = false;
1908                        CheckForUnits(ab, bb);
1909                    }
1910                }
1911            }
1912            CombatEnabled = false;
1913        }
1914
1915        private void EnterCombat(int i, int j, int ab, int bb)
1916        {
1917            if (DTerrainMap[i, j] > 9)
1918            {
1919                if (UnitMap[i, j] > -1)
1920                {
1921                    double attackerStrength;
1922                    double defenderStrength;
1923                    int chances = new int();
1924                    attackerStrength = CalculateAttackerStrength(SelectedUnit, TerrainMap[i, j], DTerrainMap[i, j], CurrentPlayer, i, j);
1925                    defenderStrength = CalculateDefenderStrength(GetUnit_FromPositionForSelection(i, j), TerrainMap[i, j], DTerrainMap[i, j], OwnershipMap[i, j], i, j);
1926                    //MessageBox.Show(attackerStrength + " " + defenderStrength);
1927                    chances = CountChances(attackerStrength, defenderStrength);
1928                    //MessageBox.Show("Chances: " + chances + " AttackerStrength: " + attackerStrength + " DefenderStrength: " + defenderStrength);
1929                    int WinNumber = RandomGen.NextInt(1, 100);
1930                    double dNumber = new double();
1931                    if (attackerStrength > defenderStrength)
1932                    {
1933                        //MessageBox.Show("attacker > defender" + " " +WinNumber + " " + chances);
1934                        if (chances < WinNumber)
1935                        {
1936                            int WinMessage = RandomGen.NextInt(1, 2);
1937                            if (WinMessage == 1 && Rules.pCivs[CurrentPlayer].HumanPlayer == true)
1938                            {
1939                                MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tuhonnut vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "in!");
1940                            }
1941                            else if (WinMessage == 2 && Rules.pCivs[CurrentPlayer].HumanPlayer == true)
1942                            {
1943                                MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tehnyt historiaa vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "ista!");
1944                            }
1945                            RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1946                            dNumber = ((WinNumber - chances));
1947                            dNumber = dNumber / 10;
1948                            dNumber = dNumber / 10;
1949                            //MessageBox.Show(Convert.ToString(dNumber));
1950                            //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP - dNumber;
1951                            UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
1952                            Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
1953                            "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
1954                            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
1955                            " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
1956                            CombatEnabled = false;
1957                            CheckForUnits(i, j);
1958                        }
1959                        else
1960                        {
1961                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on kuollut hyökätessään vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "iin!");
1962                            RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].HP);
1963                            DeselectUnit();
1964                            dNumber = ((chances - WinNumber) / 100);
1965                            Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
1966                            CombatEnabled = false;
1967                            CheckForUnits(ab, bb);
1968                        }
1969                    }
1970                    else
1971                    {
1972                        //MessageBox.Show("defender > attacker" + " " + WinNumber + " " + chances);
1973                        if (chances > WinNumber)
1974                        {
1975                            int WinMessage = RandomGen.NextInt(1, 2);
1976                            if (WinMessage == 1)
1977                            {
1978                                MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tuhonnut vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "in!");
1979                            }
1980                            else
1981                            {
1982                                MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tehnyt historiaa vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "ista!");
1983                            }
1984                            RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
1985                            dNumber = ((WinNumber - chances));
1986                            dNumber = dNumber / 10;
1987                            dNumber = dNumber / 10;
1988                            //MessageBox.Show(Convert.ToString(dNumber));
1989                            //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP - dNumber;
1990                            UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
1991                            Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
1992                            "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
1993                            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
1994                            " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
1995                            CombatEnabled = false;
1996                            CheckForUnits(i, j);
1997                        }
1998                        else
1999                        {
2000                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on kuollut hyökätessään vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "iin!");
2001                            RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].HP);
2002                            DeselectUnit();
2003                            dNumber = ((chances - WinNumber) / 100);
2004                            Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
2005                            CombatEnabled = false;
2006                            CheckForUnits(ab, bb);
2007                        }
2008                    }
2009                }
2010                else
2011                {
2012                    CityCapture(i, j, ab, bb);
2013                    UnitMap[i, j] = CurrentPlayer;
2014                    CombatEnabled = false;
2015                }
2016            }
2017            else
2018            {
2019                double attackerStrength;
2020                double defenderStrength;
2021                int chances = new int();
2022                attackerStrength = CalculateAttackerStrength(SelectedUnit, TerrainMap[i, j], DTerrainMap[i, j], CurrentPlayer, i, j);
2023                defenderStrength = CalculateDefenderStrength(GetUnit_FromPositionForSelection(i, j), TerrainMap[i, j], DTerrainMap[i, j], OwnershipMap[i, j], i, j);
2024                //MessageBox.Show(attackerStrength + " " + defenderStrength);
2025                chances = CountChances(attackerStrength, defenderStrength);
2026                int WinNumber = RandomGen.NextInt(1, 100);
2027                double dNumber = new double();
2028                //MessageBox.Show(WinNumber + " " + chances);
2029                if (attackerStrength > defenderStrength)
2030                {
2031                    if (chances < WinNumber)
2032                    {
2033                        int WinMessage = RandomGen.NextInt(1, 2);
2034                        if (WinMessage == 1)
2035                        {
2036                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tuhonnut vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "in!");
2037                        }
2038                        else
2039                        {
2040                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tehnyt historiaa vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "ista!");
2041                        }
2042                        RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
2043                        dNumber = ((WinNumber - chances));
2044                        dNumber = dNumber / 10;
2045                        dNumber = dNumber / 10;
2046                        //MessageBox.Show(Convert.ToString(dNumber));
2047                        //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP - dNumber;
2048                        UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
2049                        Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
2050                        "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
2051                        Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
2052                        " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
2053                        CombatEnabled = false;
2054                        CheckForUnits(i, j);
2055                    }
2056                    else
2057                    {
2058                        MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on kuollut hyökätessään vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "iin!");
2059                        RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].HP);
2060                        DeselectUnit();
2061                        dNumber = ((chances - WinNumber) / 100);
2062                        Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
2063                        CombatEnabled = false;
2064                        CheckForUnits(ab, bb);
2065                    }
2066                }
2067                else
2068                {
2069                    if (chances > WinNumber)
2070                    {
2071                        int WinMessage = RandomGen.NextInt(1, 2);
2072                        if (WinMessage == 1)
2073                        {
2074                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tuhonnut vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "in!");
2075                        }
2076                        else
2077                        {
2078                            MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on hyökätessään tehnyt historiaa vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "ista!");
2079                        }
2080                        RemoveUnit(i, j, OwnershipMap[i, j], Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType, Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP);
2081                        dNumber = ((WinNumber - chances));
2082                        dNumber = dNumber / 10;
2083                        dNumber = dNumber / 10;
2084                        //MessageBox.Show(Convert.ToString(dNumber));
2085                        //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP - dNumber;
2086                        UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
2087                        Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
2088                        "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
2089                        Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
2090                        " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
2091                        CombatEnabled = false;
2092                        CheckForUnits(i, j);
2093                    }
2094                    else
2095                    {
2096                        MessageDisplay.Add("Sinun " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name + " on kuollut hyökätessään vihollisen " + Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].UnitType.Name + "iin!");
2097                        RemoveUnit(ab, bb, OwnershipMap[ab, bb], Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].UnitType, Rules.pCivs[OwnershipMap[ab, bb]].Units[SelectedUnit].HP);
2098                        DeselectUnit();
2099                        dNumber = ((chances - WinNumber) / 100);
2100                        Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP = Rules.pCivs[OwnershipMap[i, j]].Units[GetUnit_FromPositionForSelection(i, j)].HP - dNumber;
2101                        CombatEnabled = false;
2102                        CheckForUnits(ab, bb);
2103                    }
2104                }
2105            }
2106            CombatEnabled = false;
2107        }
2108
2109        private void CheckForUnits(int i, int j)
2110        {
2111            if (GetUnit_FromPositionForSelection(i, j) == -1)
2112            {
2113                UnitMap[i, j] = -1;
2114                UnitTile[i, j].Image = LoadImage(Textpath + "nothing");
2115                if (DTerrainMap[i, j] < 10)
2116                {
2117                    OwnershipMap[i, j] = -1;
2118                    TileOwnership[i, j].Image = LoadImage(Textpath + "nothing");
2119                }
2120            }
2121        }
2122
2123        public int CountChances(double attackerStrength, double defenderStrength)
2124        {
2125            int chances = new int();
2126            if (defenderStrength > attackerStrength)
2127            {
2128                chances = Convert.ToInt32((((attackerStrength / defenderStrength) / 2) * 100));
2129                return chances;
2130            }
2131            else
2132            {
2133                chances = Convert.ToInt32((((defenderStrength / attackerStrength) / 2) * 100));
2134                return chances;
2135            }
2136        }
2137
2138        private void CityCaptureAI(int i, int j, int ab, int bb)
2139        {
2140            RemoveCity_FromCivFromPosition(i, j);
2141            Rules.pCivs[OwnershipMap[i, j]].NumberofCities = Rules.pCivs[OwnershipMap[i, j]].NumberofCities - 1;
2142            Rules.pCivs[OwnershipMap[i, j]].Production = Rules.pCivs[OwnershipMap[i, j]].Production - 10;
2143            MessageDisplay.TextColor = Color.Red;
2144            MessageDisplay.Add(Rules.pCivs[CurrentPlayer].Name + " on valloittanut kaupungin ruudusta " + i + "; " + j + " (" + Rules.pCivs[OwnershipMap[i, j]].Name + ")");
2145            Thread.Sleep(1000);
2146            if (Rules.pCivs[OwnershipMap[i, j]].NumberofCities == 0)
2147            {
2148                MessageDisplay.Add(Rules.pCivs[OwnershipMap[i, j]].Name + " has been destroyed!");
2149                Rules.pCivs[OwnershipMap[i, j]].Enabled = false;
2150            }
2151            OwnershipMap[i, j] = CurrentPlayer;
2152            DrawOwnership(i, j);
2153            Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY = i;
2154            Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX = j;
2155            MessageDisplay.TextColor = Color.Orange;
2156            AddCity(i, j);
2157            for (int c = 0; c < 2 + currDiffLevel; c++)
2158            {
2159                CreateUnit(i, j, Rules.Archer, CurrentPlayer);
2160            }
2161            if (GetUnit_FromPositionForSelection(ab, bb) == -1)
2162            {
2163                OwnershipMap[ab, bb] = -1;
2164                TileOwnership[ab, bb].Image = LoadImage(Textpath + "nothing");
2165            }
2166            DrawUnit(i, j);
2167        }
2168
2169        private void CityCapture(int i, int j, int ab, int bb)
2170        {
2171            RemoveCity_FromCivFromPosition(i, j);
2172            Rules.pCivs[OwnershipMap[i, j]].NumberofCities = Rules.pCivs[OwnershipMap[i, j]].NumberofCities - 1;
2173            Rules.pCivs[OwnershipMap[i, j]].Production = Rules.pCivs[OwnershipMap[i, j]].Production - 10;
2174            MessageDisplay.TextColor = Color.Red;
2175            MessageDisplay.Add(Rules.pCivs[CurrentPlayer].Name + " on valloittanut kaupungin ruudusta " + i + "; " + j + " (" + Rules.pCivs[OwnershipMap[i, j]].Name + ")");
2176            Thread.Sleep(1000);
2177            if (Rules.pCivs[OwnershipMap[i, j]].NumberofCities == 0)
2178            {
2179                MessageDisplay.Add(Rules.pCivs[OwnershipMap[i, j]].Name + " has been destroyed!");
2180                Rules.pCivs[OwnershipMap[i, j]].Enabled = false;
2181            }
2182            OwnershipMap[i, j] = CurrentPlayer;
2183            DrawOwnership(i, j);
2184            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = i;
2185            Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = j;
2186            MessageDisplay.TextColor = Color.Orange;
2187            AddCity(i, j);
2188
2189            if (GetUnit_FromPositionForSelection(ab, bb) == -1)
2190            {
2191                OwnershipMap[ab, bb] = -1;
2192                TileOwnership[ab, bb].Image = LoadImage(Textpath + "nothing");
2193            }
2194            DrawUnit(i, j);
2195        }
2196        # endregion
2197        private void AddCity(int i, int j)
2198        {
2199            Rules.pCivs[CurrentPlayer].Production = Rules.pCivs[CurrentPlayer].Production + 10;
2200            Rules.pCivs[CurrentPlayer].NumberofCities = Rules.pCivs[CurrentPlayer].NumberofCities + 1;
2201            Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 0] = i;
2202            Rules.pCivs[CurrentPlayer].CityCoords[Rules.pCivs[CurrentPlayer].NumberofCities - 1, 1] = j;
2203            BuildCityDisp.Text = "Rakenna kaupunki (B) (" + Rules.pCivs[CurrentPlayer].BuiltFromCity + " / " + Rules.pCivs[CurrentPlayer].Production + ")";
2204            CityPlaceSelection = false;
2205            ChangeProductionDispText();
2206            DTerrainMap[i, j] = CurrentPlayer + 10;
2207            DTile[i, j].Image = LoadImage(Textpath + "cityancient");
2208            CheckAndRemoveShroud_FromPos(i, j);
2209            if (OwnershipMap[i, j] == -1)
2210            {
2211                OwnershipMap[i, j] = CurrentPlayer;
2212                DrawOwnership(i, j);
2213                CheckAndRemoveShroud_FromPos(i, j);
2214            }
2215        }
2216
2217        public int GetCityPosInArray_ForRemoval(int i, int j, int civid)
2218        {
2219            for (int a = 0; a <= Rules.pCivs[civid].NumberofCities - 1; a++)
2220            {
2221                if (Rules.pCivs[civid].CityCoords[a, 0] == i && Rules.pCivs[civid].CityCoords[a, 1] == j)
2222                {
2223                    return a;
2224                }
2225            }
2226            return 0;
2227        }
2228
2229        private void RemoveCity_FromCivFromPosition(int i, int j)
2230        {
2231            int civowner = new int();
2232            civowner = OwnershipMap[i, j];
2233            int cityPosInArray = GetCityPosInArray_ForRemoval(i, j, civowner);
2234
2235            if (cityPosInArray > 0 && Rules.pCivs[civowner].NumberofCities > 2)
2236            {
2237                for (int a = cityPosInArray + 1; a <= Rules.pCivs[civowner].NumberofCities - 1; a++)
2238                {
2239                    Rules.pCivs[civowner].CityCoords[a - 1, 0] = Rules.pCivs[civowner].CityCoords[a, 0];
2240                    Rules.pCivs[civowner].CityCoords[a - 1, 1] = Rules.pCivs[civowner].CityCoords[a, 1];
2241                }
2242                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 0] = 0;
2243                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 1] = 0;
2244            }
2245            else if (cityPosInArray == 0 && Rules.pCivs[civowner].NumberofCities > 1)
2246            {
2247                for (int a = 1; a <= Rules.pCivs[civowner].NumberofCities - 1; a++)
2248                {
2249                    Rules.pCivs[civowner].CityCoords[a - 1, 0] = Rules.pCivs[civowner].CityCoords[a, 0];
2250                    Rules.pCivs[civowner].CityCoords[a - 1, 1] = Rules.pCivs[civowner].CityCoords[a, 1];
2251                }
2252                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 0] = 0;
2253                Rules.pCivs[civowner].CityCoords[Rules.pCivs[civowner].NumberofCities - 1, 1] = 0;
2254            }
2255            else if (Rules.pCivs[civowner].NumberofCities == 1)
2256            {
2257                Rules.pCivs[civowner].CityCoords[0, 0] = 0;
2258                Rules.pCivs[civowner].CityCoords[0, 1] = 0;
2259                Rules.pCivs[civowner].Enabled = false;
2260            }
2261        //    int unitpos = GetUnit_FromPositionForRemoval(i, j, unittype, unitHP);
2262        //    if (unitpos > 0 && Rules.pCivs[civnumber].NumberofUnits > 2)
2263        //    {
2264        //        MessageBox.Show("FirstMethod");
2265        //        for (int a = unitpos + 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
2266        //        {
2267        //            Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
2268        //            Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
2269        //            Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
2270        //            Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
2271        //        }
2272        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
2273        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
2274        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
2275        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
2276        //    }
2277        //    else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits > 1)
2278        //    {
2279        //        MessageBox.Show("SecondMethod");
2280        //        for (int a = 1; a <= Rules.pCivs[civnumber].NumberofUnits - 1; a++)
2281        //        {
2282        //            Rules.pCivs[civnumber].Units[a - 1].HP = Rules.pCivs[civnumber].Units[a].HP;
2283        //            Rules.pCivs[civnumber].Units[a - 1].PosY = Rules.pCivs[civnumber].Units[a].PosY;
2284        //            Rules.pCivs[civnumber].Units[a - 1].PosX = Rules.pCivs[civnumber].Units[a].PosX;
2285        //            Rules.pCivs[civnumber].Units[a - 1].UnitType = Rules.pCivs[civnumber].Units[a].UnitType;
2286        //        }
2287        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
2288        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
2289        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
2290        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
2291        //    }
2292        //    else if (unitpos == 0 && Rules.pCivs[civnumber].NumberofUnits == 1)
2293        //    {
2294        //        MessageBox.Show("ThirdMethod");
2295        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosX = 0;
2296        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].PosY = 0;
2297        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].HP = 0.0;
2298        //        Rules.pCivs[civnumber].Units[Rules.pCivs[civnumber].NumberofUnits - 1].UnitType = null;
2299        //    }
2300        //    Rules.pCivs[civnumber].NumberofUnits = Rules.pCivs[civnumber].NumberofUnits - 1;
2301        //}
2302        }
2303
2304        private void SelectNextUnit()
2305        {
2306            try
2307            {
2308                SelectedUnit = SelectedUnit + 1;
2309                UnitsSelected = true;
2310                UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
2311                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);
2312                MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
2313                UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Name +
2314                    Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Strength + Environment.NewLine +
2315                    "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Movement + Environment.NewLine +
2316                    Rules.pCivs[CurrentPlayer].Units[SelectedUnit].UnitType.Description + Environment.NewLine +
2317                    " HP: " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].HP * 100 + "/100";
2318                return;
2319            }
2320            catch
2321            {
2322                SelectedUnit = -1;
2323                UnitsSelected = false;
2324                MessageDisplay.Add("Ei ole enempää yksiköitä valittavaksi.");
2325            }
2326        }
2327
2328        private void SelectUnits()
2329        {
2330            //MessageBox.Show("SelectNextUnit");
2331            for (int a = 0; a <= Rules.pCivs[CurrentPlayer].NumberofUnits - 1; a++)
2332            {
2333                if (Rules.pCivs[CurrentPlayer].Units[a].CurrentMovementPoints == 1 | Rules.pCivs[CurrentPlayer].Units[a].CurrentMovementPoints > 1)
2334                {
2335                    SelectedUnit = a;
2336                    UnitsSelected = true;
2337                    UnitTile[Rules.pCivs[CurrentPlayer].Units[a].PosY, Rules.pCivs[CurrentPlayer].Units[a].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
2338                    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);
2339                    MessageDisplay.Add("Liikuta valittua yksikköä Numpadista.");
2340                    UnitStatsDisp.Text = "Valittu yksikkö " + "(" + Rules.pCivs[CurrentPlayer].Units[a].PosY + "; " + Rules.pCivs[CurrentPlayer].Units[a].PosX + "):" + Environment.NewLine + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Name +
2341                        Environment.NewLine + "-Voimakkuus: " + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Strength + Environment.NewLine +
2342                        "-Liikkuvuus: " + Rules.pCivs[CurrentPlayer].Units[a].UnitType.Movement + Environment.NewLine +
2343                        Rules.pCivs[CurrentPlayer].Units[a].UnitType.Description + Environment.NewLine +
2344                        " HP: " + Rules.pCivs[CurrentPlayer].Units[a].HP * 100 + "/100";
2345                    return;
2346                }
2347            }
2348        }
2349
2350        private void AIMoveUnit(int direction)
2351        {
2352            if (direction == 1)
2353            {
2354                AIUnitMovementMain(-1, -1);
2355            }
2356            else if (direction == 2)
2357            {
2358                AIUnitMovementMain(-1, 0);
2359            }
2360            else if (direction == 3)
2361            {
2362                AIUnitMovementMain(-1, 1);
2363            }
2364            else if (direction == 4)
2365            {
2366                AIUnitMovementMain(0, -1);
2367            }
2368            else if (direction == 5)
2369            {
2370                //SelectNextUnitOnTile(-1, 0);
2371            }
2372            else if (direction == 6)
2373            {
2374                AIUnitMovementMain(0, 1);
2375            }
2376            else if (direction == 7)
2377            {
2378                AIUnitMovementMain(1, -1);
2379            }
2380            else if (direction == 8)
2381            {
2382                AIUnitMovementMain(1, 0);
2383            }
2384            else if (direction == 9)
2385            {
2386                AIUnitMovementMain(1, 1);
2387            }
2388            else if (direction == 0)
2389            {
2390            }
2391        }
2392
2393        private void AIUnitMovementMain(int a, int b)
2394        {
2395            if (TerrainMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b] == Vuoristo | DTerrainMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b] == Vuoristo)
2396            {
2397                //MessageDisplay.Add("AI Pathfinding Error! at " + a + "; " + b);
2398            }
2399            else
2400            {
2401                if (Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].CurrentMovementPoints == 0 | Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].CurrentMovementPoints < 0)
2402                {
2403                    //MessageDisplay.Add("Valitulla yksiköllä ei ollut liikkumapisteitä.");
2404                    //DeselectUnit();
2405                    return;
2406                }
2407                if (OwnershipMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b] != -1 && OwnershipMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b] != (CurrentPlayer))
2408                {
2409                    AIEnterCombat(Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX);
2410                    CombatEnabled = true;
2411                    return;
2412                }
2413                Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + b;
2414                Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + a;
2415                // MessageBox.Show(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + " " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
2416                //try
2417                //{
2418                int posyK;
2419                int posxK;
2420                posyK = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + (a * -1);
2421                posxK = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + (b * -1);
2422                OwnershipMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX] = CurrentPlayer;
2423                DrawOwnership(Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX);
2424                UnitMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX] = CurrentPlayer;
2425                Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].CurrentMovementPoints = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].CurrentMovementPoints - 1;
2426                DrawUnit(Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX);
2427                Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].AIPathfindingNumber = Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].AIPathfindingNumber + 1;
2428                //MessageBox.Show(Convert.ToString(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints));
2429                if (GetUnit_FromPositionForSelection(Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + (b * -1)) == -1)
2430                {
2431                    UnitMap[posyK, posxK] = -1;
2432                    UnitTile[posyK, posxK].Image = LoadImage(Textpath + "nothing");
2433                    if (CheckforCityinPos(Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + (b * -1), CurrentPlayer) == -1)
2434                    {
2435                        OwnershipMap[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + (b * -1)] = -1;
2436                        TileOwnership[Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[AISelectedUnit].PosX + (b * -1)].Image = LoadImage(Textpath + "nothing");
2437                    }
2438                }
2439            }
2440        }
2441
2442        private void MoveUnit(int direction)
2443        {
2444            if (SelectedUnit == -1)
2445            {
2446                MessageDisplay.Add("Ei ole yksikköä valittuna.");
2447            }
2448            else
2449            {
2450                if (direction == 1)
2451                {
2452                    UnitMovementMain(-1, -1);
2453                }
2454                else if (direction == 2)
2455                {
2456                    UnitMovementMain(-1, 0);
2457                }
2458                else if (direction == 3)
2459                {
2460                    UnitMovementMain(-1, 1);
2461                }
2462                else if (direction == 4)
2463                {
2464                    UnitMovementMain(0, -1);
2465                }
2466                else if (direction == 5)
2467                {
2468                    //SelectNextUnitOnTile(-1, 0);
2469                }
2470                else if (direction == 6)
2471                {
2472                    UnitMovementMain(0, 1);
2473                }
2474                else if (direction == 7)
2475                {
2476                    UnitMovementMain(1, -1);
2477                }
2478                else if (direction == 8)
2479                {
2480                    UnitMovementMain(1, 0);
2481                }
2482                else if (direction == 9)
2483                {
2484                    UnitMovementMain(1, 1);
2485                }
2486                //if (CombatEnabled == false)
2487                //{
2488                //    if (Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints == 0)
2489                //    {
2490                //        DeselectUnit();
2491                //    }
2492                //    else
2493                //    {
2494                //        UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
2495                //    }
2496                //}
2497            }
2498        }
2499
2500        private void UnitMovementMain(int a, int b)
2501        {
2502            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)
2503            {
2504                MessageDisplay.Add("Et voi liikkua vuorten läpi!");
2505            }
2506            else
2507            {
2508                if (Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints == 0 | Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints < 0)
2509                {
2510                    MessageDisplay.Add("Valitulla yksiköllä ei ollut liikkumapisteitä.");
2511                    DeselectUnit();
2512                    return;
2513                }
2514                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))
2515                {
2516                    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);
2517                    CombatEnabled = true;
2518                    return;
2519                }
2520                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + b;
2521                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + a;
2522                // MessageBox.Show(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + " " + Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
2523                //try
2524                //{
2525                int posyK;
2526                int posxK;
2527                posyK = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1);
2528                posxK = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1);
2529                OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
2530                DrawOwnership(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
2531                UnitMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX] = CurrentPlayer;
2532                CheckAndRemoveShroud_FromPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
2533                Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints - 1;
2534                DrawUnit(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX);
2535                //MessageBox.Show(Convert.ToString(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].CurrentMovementPoints));
2536                if (GetUnit_FromPositionForSelection(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)) == -1)
2537                {
2538                    UnitMap[posyK, posxK] = -1;
2539                    UnitTile[posyK, posxK].Image = LoadImage(Textpath + "nothing");
2540                    if (CheckforCityinPos(Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1), CurrentPlayer) == -1)
2541                    {
2542                        OwnershipMap[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)] = -1;
2543                        TileOwnership[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY + (a * -1), Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX + (b * -1)].Image = LoadImage(Textpath + "nothing");
2544                    }
2545                }
2546                //catch
2547                //{
2548                //MessageDisplay.Add("Et voi liikkua kartan ulkopuolelle!");
2549                //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX - b;
2550                //Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY = Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY - a;
2551                //}
2552                //}
2553            }
2554        }
2555
2556        private void DrawUnit(int i, int j)
2557        {
2558            UnitTile[i, j].Image = LoadImage(OwnershipColorPath + "unitsOnTileSelected");
2559            UnitTile[i, j].IsVisible = true;
2560            //Add(UnitTile[i, j]);
2561        }
2562
2563        private void DeselectUnit()
2564        {
2565            try
2566            {
2567                UnitTile[Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosY, Rules.pCivs[CurrentPlayer].Units[SelectedUnit].PosX].Image = LoadImage(OwnershipColorPath + "unitsOnTile");
2568                UnitsSelected = false;
2569                SelectedUnit = -1;
2570            }
2571            catch
2572            {
2573            }
2574        }
2575
2576        public int CheckforCityinPos(int i, int j, int civid)
2577        {
2578            int returnvalue = new int();
2579            if (DTerrainMap[i, j] - 10 == civid)
2580            {
2581                returnvalue = civid;
2582            }
2583            else
2584            {
2585                returnvalue = -1;
2586            }
2587            return returnvalue;
2588        }
2589
2590        private void ActivateDebug(int asd)
2591        {
2592            //Add(MessageDisplay);
2593            MessageDisplay.Add("DEBUG MODE ACTIVATED");
2594            Keyboard.Listen(Key.A, Jypeli.ButtonState.Down, ShowColors, null);
2595        }
2596
2597        private void ShowColors()
2598        {
2599            for (int a = 0; a <= (AmountofPlayers - 1); a++)
2600            {
2601                MessageDisplay.Add("Pelaaja: " + a + "; " + Rules.pCivs[a].Color);
2602            }
2603        }
2604
2605        private void MoveCamera(Int32 dir)
2606        {
2607            if (gamestarted == false) { return; }
2608            if ((dir == 0)  && (Camera.Position.X < (tile[kartanKorkeus - 1, kartanLeveys - 1].X) - ((Peli.Screen.Width / 2) - 200)))
2609            {
2610                Camera.Move(CamSpeedEast);
2611            }
2612            if ((dir == 1) && (Camera.Position.Y < (tile[kartanKorkeus - 1, kartanLeveys - 1].Y) - ((Peli.Screen.Height / 2) - 12)))
2613            {
2614                Camera.Move(CamSpeedNorth);
2615            }
2616            if ((dir == 2) && (Camera.Position.X > (tile[0, 0].X) + (Peli.Screen.Width / 2)))
2617            {
2618                Camera.Move(CamSpeedWest);
2619            }
2620            if ((dir == 3) && (Camera.Position.Y > (tile[0, 0].Y) + (Peli.Screen.Height / 2)))
2621            {
2622                Camera.Move(CamSpeedSouth);
2623            }
2624        }
2625    }
2626}
Note: See TracBrowser for help on using the repository browser.