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

Revision 971, 110.2 KB checked in by ramipasa, 11 years ago (diff)

Lisätty pelilogiikkaa (taistelut nyt toimivat, ainakin suurimmaksi osaksi), korjattu bugeja (ja tuotu taistelun mukana mahdollisesti uusia) sekä lisätty pakettiin ALTKCore (Avaruuslaatikko 5 Core) ja BaseRules? (Avaruuslaatikko 5 Rules) -kirjastot.

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