Subversion Repositories BlockadePP

Rev

Rev 1 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 freddie 1
using System;
2
using System.Collections.Generic;
3
using System.ComponentModel;
4
using System.Data;
5
using System.Drawing;
6
using System.Text;
7
using System.Windows.Forms;
8
 
9
namespace blockade
10
{
11
    public partial class Form1 : Form
12
    {
13
 
14
        public class smoke
15
        {
16
            public Color colour;
17
            public Point loc;
18
            public int time;
19
 
20
            public smoke(Color colourN, Point locN, int timeN)
21
            {
22
                colour = colourN;
23
                loc = locN;
24
                time = timeN;
25
            }
26
        }
27
 
28
        public class enemyType
29
        {
30
            public float health, speed, spawnChance;
31
            public int child, value, spawn;
32
            public animg img;
33
 
34
            public Image getImg()
35
            {
36
                return img.curImg();
37
            }
38
 
39
            public Image getImg(int num)
40
            {
41
                img.runTime = num;
42
                return img.curImg();
43
            }
44
 
45
            public enemyType(string healthN, string speedN, string childN, string spawnN, string spawnChanceN, string imgN)
46
            {
47
                health = float.Parse(healthN);
48
                speed = float.Parse(speedN);
49
                child = int.Parse(childN);
50
                img = new animg(imgN);
51
                spawn = int.Parse(spawnN);
52
                spawnChance = float.Parse(spawnChanceN);
53
                value = (int)(speed * health / 20 + health / 20);
54
            }
55
 
56
            public enemyType(string[] data)
57
            {
58
                health = float.Parse(data[0]);
59
                speed = float.Parse(data[1]);
60
                child = int.Parse(data[2]);
61
                spawn = int.Parse(data[3]);
62
                spawnChance = float.Parse(data[4]);
63
                img = new animg(data[5]);
64
                value = (int)(speed * health / 50 + health / 20);
65
            }
66
        }
67
 
68
        public class enemy
69
        {
70
            public int type;
71
            public float health;
72
            public float angle;
73
            public PointF loc;
74
            public int imgTime;
75
            public float dX, dY;
76
 
77
            public void incImg()
78
            {
79
                imgTime++;
80
            }
81
 
82
            public enemy(int typeN, float healthN, float angleN, PointF locN)
83
            {
84
                // have to pass health, enemy cannot work it out
85
                type = typeN;
86
                health = healthN;
87
                angle = angleN;
88
                loc = locN;
89
            }
90
        }
91
 
92
        public class missileType
93
        {
94
            public Image img;
95
            public int speed, damage, spread;
96
            public float energy;
97
 
98
            public missileType(string imgN, string speedN, string damageN, string spreadN, string energyN)
99
            {
100
                img = Image.FromFile(imgN);
101
                speed = int.Parse(speedN);
102
                damage = int.Parse(damageN);
103
                spread = int.Parse(spreadN);
104
            }
105
 
106
            public missileType(string[] data)
107
            {
108
                img = Image.FromFile(data[0]);
109
                speed = int.Parse(data[1]);
110
                damage = int.Parse(data[2]);
111
                spread = int.Parse(data[3]);
112
            }
113
        }
114
 
115
        public class towerType
116
        {
117
            public Color laserColour;
118
            public int missileID;
119
            public float maxEnergy, gainRate, useRate, damage;
120
            public int cost, range, laserType, extRange, killNum;
121
            public animg baseImg, turretImg;
122
            public int req, delay;
123
            public string sound;
124
            public string name;
125
            public string[] details;
126
 
127
            public Image getBaseImg()
128
            {
129
                return baseImg.curImg();
130
            }
131
 
132
            public Image getTurretImg()
133
            {
134
                return turretImg.curImg();
135
            }
136
 
137
            public Image getBaseImg(int num)
138
            {
139
                baseImg.runTime = num;
140
                return baseImg.curImg();
141
            }
142
 
143
            public Image getTurretImg(int num)
144
            {
145
                turretImg.runTime = num;
146
                return turretImg.curImg();
147
            }
148
 
149
            public towerType(string laserColourN, string maxEnergyN, string gainRateN, string useRateN, string rangeN, string costN, string reqN, string delayN, string baseImgN, string turretImgN, string soundN, string laserTypeN, string extRangeN, string killNumN, string nameN, string detailsN)
150
            {
151
                laserColour = Color.FromName(laserColourN);
152
                maxEnergy = int.Parse(maxEnergyN);
153
                gainRate = float.Parse(gainRateN);
154
                useRate = float.Parse(useRateN);
155
                damage = useRate;
156
                cost = int.Parse(costN);
157
                range = int.Parse(rangeN);
158
                req = int.Parse(reqN);
159
                delay = int.Parse(delayN);
160
                baseImg = new animg(baseImgN);
161
                turretImg = new animg(turretImgN);
162
                sound = soundN;
163
                laserType = int.Parse(laserTypeN);
164
                extRange = int.Parse(extRangeN);
165
                killNum = int.Parse(killNumN);
166
                name = nameN;
167
                details = detailsN.Split(':');
168
 
169
                for (int i = 0; i < details.Length; i++)
170
                        details[i] = details[i].Replace('`', ',');
171
            }
172
 
173
            public towerType(string missileIDN, string maxEnergyN, string gainRateN, string rangeN, string costN, string reqN, string delayN, string baseImgN, string turretImgN, string soundN, string nameN, string detailsN)
174
            {
175
                missileID = int.Parse(missileIDN);
176
                maxEnergy = int.Parse(maxEnergyN);
177
                gainRate = float.Parse(gainRateN);
178
                cost = int.Parse(costN);
179
                range = int.Parse(rangeN);
180
                req = int.Parse(reqN);
181
                delay = int.Parse(delayN);
182
                baseImg = new animg(baseImgN);
183
                turretImg = new animg(turretImgN);
184
                sound = soundN;
185
                name = nameN;
186
                details = detailsN.Split(':');
187
 
188
                for (int i = 0; i < details.Length; i++)
189
                        details[i] = details[i].Replace('`', ',');
190
            }
191
 
192
            public towerType(string[] data)
193
            {
194
 
195
                if (data.Length == 16)
196
                {
197
                    laserColour = Color.FromName(data[0]);
198
                    maxEnergy = int.Parse(data[1]);
199
                    gainRate = float.Parse(data[2]);
200
                    useRate = float.Parse(data[3]);
201
                    damage = useRate;
202
                    cost = int.Parse(data[4]);
203
                    range = int.Parse(data[5]);
204
                    req = int.Parse(data[6]);
205
                    delay = int.Parse(data[7]);
206
                    baseImg = new animg(data[8]);
207
                    turretImg = new animg(data[9]);
208
                    sound = @"data/" + data[10];
209
                    laserType = int.Parse(data[11]);
210
                    extRange = int.Parse(data[12]);
211
                    killNum = int.Parse(data[13]);
212
                    name = data[14];
213
                    details = data[15].Split(':');
214
                }
215
                else
216
                {
217
                    missileID = int.Parse(data[0]);
218
                    maxEnergy = int.Parse(data[1]);
219
                    gainRate = float.Parse(data[2]);
220
                    cost = int.Parse(data[3]);
221
                    range = int.Parse(data[4]);
222
                        req = int.Parse(data[5]);
223
                        delay = int.Parse(data[6]);
224
                        baseImg = new animg(data[7]);
225
                    turretImg = new animg(data[8]);
226
                    sound = @"data/" + data[9];
227
                    name = data[10];
228
                    details = data[11].Split(':');
229
                }
230
 
231
                for (int i = 0; i < details.Length; i++)
232
                        details[i] = details[i].Replace('`', ',');
233
 
234
            }
235
        }
236
 
237
        public class tower
238
        {
239
            public int type, delayTime;
240
            public float energy, glow, angle;
241
            public bool fireing;
242
            public Point loc;
243
            public int baseTime, turretTime;
244
            public List<int> targets;
245
//            public WMPLib.WindowsMediaPlayer s;
246
 
247
                        public int target
248
                        {
249
                                get
250
                                {
251
                                        if (targets.Count != 0)
252
                                                return targets[0];
253
                                        else
254
                                                return -1;
255
                                }
256
                                set
257
                                {
258
                                        if (value == -1)
259
                                                targets.Clear();
260
                                        else if (targets.Count == 0)
261
                                                targets.Add(value);
262
                                        else
263
                                                targets[0] = value;
264
                                }
265
                        }
266
 
267
            public void incImgs()
268
            {
269
                baseTime++;
270
                turretTime++;
271
            }
272
 
273
            public tower(int typeN, Point locN, string soundLoc)
274
            {
275
                targets = new List<int>();
276
                type = typeN;
277
                target = -1;
278
                energy = 0;
279
                glow = 0;
280
                fireing = false;
281
                loc = locN;
282
                angle = 180.0f;
283
                baseTime = 0;
284
                turretTime = 0;
285
                delayTime = 0;
286
//                s = new WMPLib.WindowsMediaPlayer();
287
//                s.settings.autoStart = false;
288
//                s.settings.volume = 50;
289
//                s.URL = soundLoc;
290
            }
291
 
292
        }
293
 
294
        /// <summary>
295
        /// Animated Img for Blockade
296
        /// </summary>
297
        public class animg
298
        {
299
 
300
                public Image[] imgs;
301
                public int[] delays;
302
                public int runTime, maxRunTime;
303
                public string stringEq;
304
 
305
                public void inc()
306
                {
307
                        runTime++;
308
                        if (runTime > maxRunTime)
309
                                runTime = 0;
310
                }
311
 
312
                public Image curImg()
313
                {
314
                                int cDelay = 0;
315
                        for (int i = 0; i < delays.Length; i++)
316
                        {
317
                                cDelay += delays[i];
318
                                if (cDelay > runTime)
319
                                        return imgs[i];
320
                        }
321
 
322
                        return imgs[0];
323
                }
324
 
325
                public animg clone()
326
                {
327
                        return new animg(stringEq);
328
                }
329
 
330
                public animg(string s)
331
                {
332
                        stringEq = s;
333
                        string[] data = s.Split(':');
334
 
335
                        imgs = new Image[(int)(data.Length / 2)];
336
                        delays = new int[(int)(data.Length / 2)];
337
 
338
                                int cDelay = 0;
339
                        for (int i = 0; i < data.Length; i += 2)
340
                        {
341
                                imgs[(int)(i / 2)] = Image.FromFile(@"data/" + data[i]);
342
                                delays[(int)(i / 2)] = int.Parse(data[i + 1]);
343
                                cDelay += delays[(int)(i / 2)];
344
                        }
345
 
346
                        maxRunTime = cDelay;
347
 
348
                }
349
 
350
        }
351
 
352
        public List<smoke> smokes = new List<smoke>();
353
 
354
        public List<enemyType> enemyTypes = new List<enemyType>();
355
        public List<missileType> missileTypes = new List<missileType>();
356
        public List<towerType> towerTypes = new List<towerType>();
357
 
358
        public List<enemy> enemies = new List<enemy>();
359
        public List<tower> towers = new List<tower>();
360
 
361
        public List<PictureBox> icons = new List<PictureBox>();
362
 
363
        string[] laserType0, laserType1, laserType2, cashA, livesA, levelA;
364
        string[] laserTypeLookup;
365
 
366
        string[] levels;
367
 
368
        public int selTowerType = 0;
369
        public int cash;
370
        public int lives;
371
        public int level = 0;
372
        public int fCount;
373
        public bool energyBars, autoRun, rangeRings, sound;
374
        public Image yesImg, noImg, selImg, bgImg;
375
        public float smokeMul;
376
        public Color controlBGColour, controlFGColour;
377
                public string detailText = "";        
378
                public int lang;
379
 
7 freddie 380
                public bool extraPretty = false;
1 freddie 381
        Random rnd = new Random();
382
 
383
        public Form1(int language)
384
        {
385
            InitializeComponent();
386
            lang = language;
387
        }
388
 
389
        void mainLoop()
390
        {
391
                System.Threading.Thread.Sleep(1);
392
            while (enemies.Count > 0)
393
            {
394
                fCount++;
395
                Application.DoEvents();
396
                enemyLoop();
397
                towerLoop();
398
                missileLoop();
399
                smokeLoop();
400
                Application.DoEvents();
401
                draw();
402
            }
403
            cash += (int)(lives / 2);
404
            level++;
405
            if (autoRun)
406
                newRun();
407
            else
408
            {
409
                smokes.Clear();
410
                draw();
411
            }
412
        }
413
 
414
        void enemyLoop()
415
        {
416
            for (int i = enemies.Count - 1; i >= 0; i--)
417
            {
418
                enemies[i].incImg();
419
                if (enemies[i].health <= 0)
420
                {
421
                        cash += enemyTypes[enemies[i].type].value;
422
                    if (enemyTypes[enemies[i].type].child == -1)
423
                    {
424
                        enemies.RemoveAt(i);
425
                        for (int j = 0; j < towers.Count; j++)
426
                        {
427
                                // loop removed
428
                                if (towers[j].target > i)
429
                                towers[j].target--;
430
                            else if (towers[j].target == i)
431
                                towers[j].target = -1;
432
                        }
433
                    }
434
                    else
435
                    {
436
                        enemies[i].type = enemyTypes[enemies[i].type].child;
437
                        enemies[i].health = enemyTypes[enemies[i].type].health;
438
                        initMove(i);
439
                    }
440
                }
441
                else
442
                {
443
                    move(i);
444
                        if (enemyTypes[enemies[i].type].spawn != -1)
445
                        {
446
                                if (rnd.NextDouble() < enemyTypes[enemies[i].type].spawnChance)
447
                                {
448
                                        enemies.Add(new enemy(enemyTypes[enemies[i].type].spawn, enemyTypes[enemyTypes[enemies[i].type].spawn].health, (float)getAngle(FtoP(enemies[i].loc), new Point(500, rnd.Next(40,360))), enemies[i].loc));
449
                                        initMove(enemies.Count - 1);
450
                                }
451
                        }
452
                    if (enemies[i].loc.X > 500)
453
                    {
454
                        lives--;
455
                        enemies.RemoveAt(i);
456
                        for (int j = 0; j < towers.Count; j++)
457
                        {
458
                                // loop removed
459
                                if (towers[j].target > i)
460
                                towers[j].target--;
461
                            else if (towers[j].target == i)
462
                                towers[j].target = -1;
463
                        }
464
                    }
465
                }
466
            }
467
        }
468
 
469
        void towerLoop()
470
        {
471
            for (int i = 0; i < towers.Count; i++)
472
            {
473
                towers[i].incImgs();
474
                if (towers[i].glow > 0)
475
                        towers[i].glow--;
476
                if (towers[i].delayTime != 0)
477
                    towers[i].delayTime--;
478
 
479
                if (towers[i].target == -1 || getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) > towerTypes[towers[i].type].range)
480
                {
481
                        towers[i].target = -1;
482
                    reTarget(i);
483
                }
484
                else if (towerTypes[towers[i].type].req != 0 && towers[i].energy >= towerTypes[towers[i].type].req)
485
                {
486
                        if (towerTypes[towers[i].type].laserType == 2)
487
                                reTarget(i);
488
                        fire(i, true);
489
                }
490
                reAngle(i);
491
                if (towers[i].fireing && towers[i].target != -1 && towers[i].energy >= towerTypes[towers[i].type].useRate)
492
                {
493
//                              towers[i].s.controls.play();
494
                    if (towerTypes[towers[i].type].laserColour == null)
495
                    {
496
                    }
497
                    else if (towers[i].delayTime == 0)
498
                    {
499
                        towers[i].energy -= towerTypes[towers[i].type].useRate;
500
                        int smokeSpreadWidth = (int)(getEnemyImg(towers[i].target).Width / 3);
501
                        int smokeSpreadHeight = (int)(getEnemyImg(towers[i].target).Height / 3);
502
                        int num = rnd.Next(1, (int)(towerTypes[towers[i].type].useRate / 100 + 2));
503
                        switch (towerTypes[towers[i].type].laserType)
504
                        {
505
                                case (0):
506
                                {
507
                                        enemies[towers[i].target].health -= towerTypes[towers[i].type].damage;
508
                                        for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 + 0.5); j++)
509
                                                smokes.Add(new smoke(towerTypes[towers[i].type].laserColour, new Point((int)enemies[towers[i].target].loc.X + rnd.Next(-smokeSpreadWidth, smokeSpreadWidth), (int)enemies[towers[i].target].loc.Y + rnd.Next(-smokeSpreadHeight, smokeSpreadHeight)), 20));
510
                                        break;
511
                                }
512
                                case (1):
513
                                {
514
                                        enemies[towers[i].target].health -= towerTypes[towers[i].type].damage;
515
                                        for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 + 0.5); j++)
516
                                                smokes.Add(new smoke(towerTypes[towers[i].type].laserColour, new Point((int)enemies[towers[i].target].loc.X + rnd.Next(-smokeSpreadWidth, smokeSpreadWidth), (int)enemies[towers[i].target].loc.Y + rnd.Next(-smokeSpreadHeight, smokeSpreadHeight)), 20));
517
                                        break;
518
                                }
519
                                case (2):
520
                                {
521
                                        for (int r = 0; r < towers[i].targets.Count; r++)
522
                                        {
523
                                                enemies[towers[i].targets[r]].health -= towerTypes[towers[i].type].damage / (float)towers[i].targets.Count;
524
                                                for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 / (float)towers[i].targets.Count + 0.5); j++)
525
                                                        smokes.Add(new smoke(towerTypes[towers[i].type].laserColour, new Point((int)enemies[towers[i].targets[r]].loc.X + rnd.Next(-smokeSpreadWidth, smokeSpreadWidth), (int)enemies[towers[i].targets[r]].loc.Y + rnd.Next(-smokeSpreadHeight, smokeSpreadHeight)), 20));
526
                                        }
527
                                        break;
528
                                }
529
                        }
530
                        towers[i].glow = towerTypes[towers[i].type].useRate;
531
                        towers[i].delayTime += towerTypes[towers[i].type].delay;
532
                    }
533
                }
534
                else
535
                {
536
                        fire(i, false);
537
                        towers[i].energy += towerTypes[towers[i].type].gainRate - rnd.Next(0, (int)Math.Ceiling((towerTypes[towers[i].type].gainRate / 5)));
538
                    if (towers[i].energy >= towerTypes[towers[i].type].maxEnergy && towers[i].target != -1)
539
                        {
540
                        towers[i].energy = towerTypes[towers[i].type].maxEnergy;
541
                    }
542
                }
543
                if (towers[i].energy > towerTypes[towers[i].type].maxEnergy)
544
                        towers[i].energy = towerTypes[towers[i].type].maxEnergy;
545
            }
546
        }
547
 
548
        void missileLoop()
549
        {
550
 
551
        }
552
 
553
        void smokeLoop()
554
        {
555
            for (int i = smokes.Count - 1; i >= 0 ; i--)
556
            {
557
                smokes[i].time--;
558
                if (smokes[i].time <= 0)
559
                    smokes.RemoveAt(i);
560
            }
561
        }
562
 
563
        void newRun()
564
        {
565
            if (level >= levels.Length)
566
            {
567
                level = 0;
568
                for (int i = 0; i < enemyTypes.Count; i++)
569
                {
570
                        enemyTypes[i].health *= 1.2f;
571
                }
572
            }
573
            string[] data = levels[level].Split(',');
574
            PointF start;
575
            Point end;
576
            for (int i = 0; i < data.Length; i++)
577
            {
578
                start = new PointF(rnd.Next(-150, -55), rnd.Next(40, 360));
579
                end = new Point(500, rnd.Next(40, 360));
580
                enemies.Add(new enemy(int.Parse(data[i]), enemyTypes[int.Parse(data[i])].health, (float)getAngle(FtoP(start), end), start));
581
                initMove(enemies.Count - 1);
582
                enemies[enemies.Count - 1].imgTime = rnd.Next(enemyTypes[enemies[enemies.Count - 1].type].img.maxRunTime);
583
            }
584
            mainLoop();
585
        }
586
 
587
        private void Form1_Load(object sender, EventArgs e)
588
        {
589
            initAll();
590
        }
591
 
592
        public void initAll()
593
        {
594
 
595
                // handels
596
 
597
                System.IO.StreamReader reader;
598
                string r;
599
            string[] lines;
600
 
601
                // textLookUps
602
 
603
            reader = new System.IO.StreamReader(@"data/gameTexts.dat", Encoding.UTF8);
604
            lines = reader.ReadToEnd().Split('\n');
605
 
606
            laserType0 = lines[0].Split(':');
607
            laserType1 = lines[1].Split(':');
608
            laserType2 = lines[2].Split(':');
609
            cashA = lines[3].Split(':');
610
            livesA = lines[4].Split(':');
611
            levelA = lines[5].Split(':');
612
 
613
            laserTypeLookup = new String[3];
614
            laserTypeLookup[0] = laserType0[lang];
615
            laserTypeLookup[1] = laserType1[lang];
616
            laserTypeLookup[2] = laserType2[lang];
617
 
618
            // init start vars
619
 
620
            reader = new System.IO.StreamReader(@"data/start.dat", Encoding.UTF8);
621
            r = reader.ReadToEnd();
622
            reader.Close();
623
            string[] data = r.Split(',');
624
            cash = int.Parse(data[0]);
625
            lives = int.Parse(data[1]);
626
            bgImg = Image.FromFile(@"data/" + data[2]);
627
            beamF.Image = Image.FromFile(@"data/" + data[3]);
628
            smokeMul = float.Parse(data[4]);
629
            controlBGColour = Color.FromName(data[5]);
630
            controlFGColour = Color.FromName(data[6]);
631
 
632
            // basic UI stuff
633
 
634
            this.Text = "Blockade!";
635
            yesImg = Image.FromFile(@"data/yesImg.png");
636
            noImg = Image.FromFile(@"data/noImg.png");
637
            selImg = Image.FromFile(@"data/selImg.png");
638
            goF.BackColor = controlBGColour;
639
                goF.BackgroundImage = yesImg;
640
            goF.Image = Image.FromFile(@"data/go.png");
641
            cashF.BackColor = controlBGColour;
642
            livesF.BackColor = controlBGColour;
643
            levelF.BackColor = controlBGColour;
644
            cashF.ForeColor = controlFGColour;
645
            livesF.ForeColor = controlFGColour;
646
            levelF.ForeColor = controlFGColour;
647
 
648
 
649
            // load ingame object types
650
 
651
            reader = new System.IO.StreamReader(@"data/enemies.dat", Encoding.UTF8);
652
            r = reader.ReadToEnd();
653
            reader.Close();
654
            lines = r.Split('\n');
655
            for (int i = 0; i < lines.Length; i++)
656
            {
657
                if (lines[i].Length != 0 && lines[i].Substring(0,1) != "#")
658
                    enemyTypes.Add(new enemyType(lines[i].Split(',')));
659
            }
660
 
661
            reader = new System.IO.StreamReader(@"data/missiles.dat", Encoding.UTF8);
662
            r = reader.ReadToEnd();
663
            reader.Close();
664
            lines = r.Split('\n');
665
            for (int i = 0; i < lines.Length; i++)
666
            {
667
                if (lines[i].Length != 0 && lines[i].Substring(0,1) != "#")
668
                    missileTypes.Add(new missileType(lines[i].Split(',')));
669
            }
670
 
671
            reader = new System.IO.StreamReader(@"data/towers.dat", Encoding.UTF8);
672
            r = reader.ReadToEnd();
673
            reader.Close();
674
            lines = r.Split('\n');
675
            for (int i = 0; i < lines.Length; i++)
676
            {
677
                if (lines[i].Length != 0 && lines[i].Substring(0, 1) != "#")
678
                    towerTypes.Add(new towerType(lines[i].Split(',')));
679
            }
680
 
681
            // load levels
682
 
683
            reader = new System.IO.StreamReader(@"data/levels.dat");
684
            r = reader.ReadToEnd();
685
            reader.Close();
686
            levels = r.Split('\n');
687
 
688
            // set up Icons
689
 
690
            Point iconLoc = new Point();
691
 
692
            for (int i = 0; i < towerTypes.Count; i++)
693
            {
694
                icons.Add(new PictureBox());
695
                icons[i].BackColor = controlBGColour;
696
                icons[i].SizeMode = PictureBoxSizeMode.Zoom;
697
                icons[i].Image = towerTypes[i].turretImg.imgs[0];
698
                iconLoc.X = 150 + (int)Math.Floor(i / 2.0) * 48;
699
                icons[i].Visible = true;
700
                icons[i].Click += new EventHandler(IconPress);
701
                if ((float)Math.Floor(i / 2.0) != (float)(i / 2.0))
702
                    iconLoc.Y = 454;
703
                else
704
                    iconLoc.Y = 408;
705
                icons[i].Location = iconLoc;
706
                icons[i].Tag = i;
707
                icons[i].Size = new Size(40, 40);
708
                icons[i].MouseHover += new EventHandler(IconEnter);
709
                icons[i].MouseLeave += new EventHandler(IconLeave);
710
                Controls.Add(icons[i]);
711
                icons[i].BringToFront();
712
                icons[i].Refresh();
713
            }
714
 
715
            // close reader
716
 
717
            reader.Close();
718
 
719
            // Draw everything...
720
 
721
            drawBG();
722
            draw();
723
 
724
        }
725
 
726
        public float notZero(float value)
727
        {
728
                if (value == 0)
729
                        return 0.01f;
730
                else
731
                        return value;
732
        }
733
 
734
        public void draw()
735
        {
736
 
737
                for (int i = 0; i < icons.Count; i++)
738
                {
739
                        if (cash < towerTypes[i].cost)
740
                                icons[i].BackgroundImage = noImg;
741
                        else if (selTowerType == i)
742
                                icons[i].BackgroundImage = selImg;
743
                        else
744
                                icons[i].BackgroundImage = yesImg;
745
                }
746
 
747
                cashF.Text = cashA[lang] + ": " + cash.ToString();
748
                livesF.Text = lives.ToString() + " " + livesA[lang];
749
                levelF.Text = levelA[lang] + ": " + level.ToString();
750
 
751
            Bitmap img = new Bitmap(500, 400);
752
            Graphics g = Graphics.FromImage(img);
753
                        PointF[] points;
754
 
755
            // draw towers
756
            Image baseImg, turretImg;
757
            for (int i = 0; i < towers.Count; i++)
758
            {
759
                baseImg = getBaseImg(i);
760
                turretImg = getTurretImg(i);
761
                if (towers[i].fireing && towers[i].delayTime == towerTypes[towers[i].type].delay && towerTypes[towers[i].type].laserColour != null && towers[i].target != -1)
762
                {
763
                        switch (towerTypes[towers[i].type].laserType)
764
                        {
765
                                case (0):
766
                                        {
767
                                g.DrawLine(new Pen(towerTypes[towers[i].type].laserColour, 3), (PointF)towers[i].loc, enemies[towers[i].target].loc);
768
                                break;
769
                                        }
770
                                case (1):
771
                        {
772
                                        //laser
773
                                        points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) / 50 + 3];
774
                                                points[0] = enemies[towers[i].target].loc;
775
                                                        points[points.Length - 1] = towers[i].loc;
776
                                                for (int j = 1; j < points.Length - 1; j++)
777
                                                        points[j] = new PointF(enemies[towers[i].target].loc.X + notZero(towers[i].loc.X - (int)enemies[towers[i].target].loc.X) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4), enemies[towers[i].target].loc.Y + notZero(towers[i].loc.Y - (int)enemies[towers[i].target].loc.Y) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4));
778
                                                g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points);
7 freddie 779
                                                if (extraPretty)
780
                                                {
781
                                                        for (int j = 0; j < 3; j++)
782
                                                                g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 1), rndmisePoints(points, true));
783
                                                }
1 freddie 784
                                                break;
785
                        }
786
                                case (2):
787
                        {
788
                                        //initialLaser
789
                                        points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) / 50 + 3];
790
                                                points[0] = enemies[towers[i].target].loc;
791
                                                        points[points.Length - 1] = towers[i].loc;
792
                                                for (int j = 1; j < points.Length - 1; j++)
793
                                                        points[j] = new PointF(enemies[towers[i].target].loc.X + notZero(towers[i].loc.X - (int)enemies[towers[i].target].loc.X) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4), enemies[towers[i].target].loc.Y + notZero(towers[i].loc.Y - (int)enemies[towers[i].target].loc.Y) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4));
794
                                                g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points);
7 freddie 795
                                                if (extraPretty)
796
                                                {
797
                                                        for (int j = 0; j < 3; j++)
798
                                                                g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 1), rndmisePoints(points, true));
799
                                                }
1 freddie 800
                                        //furtherLasers
801
                                        for (int r = 1; r < towers[i].targets.Count; r++)
802
                                        {
803
                                                points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].targets[r]].loc)) / 50 + 3];
804
                                                points[0] = enemies[towers[i].targets[r]].loc;
805
                                                                points[points.Length - 1] = enemies[towers[i].targets[r - 1]].loc;
806
                                                        for (int j = 1; j < points.Length - 1; j++)
807
                                                                points[j] = new PointF(enemies[towers[i].targets[r]].loc.X + notZero(enemies[towers[i].targets[r - 1]].loc.X - (int)enemies[towers[i].targets[r]].loc.X) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4), enemies[towers[i].targets[r]].loc.Y + notZero(enemies[towers[i].targets[r - 1]].loc.Y - (int)enemies[towers[i].targets[r]].loc.Y) / points.Length * j + rnd.Next(-points.Length - 4, points.Length + 4));
808
                                                        g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points);
7 freddie 809
                                                        if (extraPretty)
810
                                                        {
811
                                                                for (int j = 0; j < 3; j++)
812
                                                                        g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 1), rndmisePoints(points, true));
813
                                                        }
1 freddie 814
                                        }
815
                                                break;
816
                        }
817
                        }
818
                }
819
 
820
                g.TranslateTransform(towers[i].loc.X, towers[i].loc.Y);
821
                if (energyBars)
822
                {
823
                        if (towers[i].fireing)
824
                                g.FillRectangle(Brushes.Maroon, (int)(-turretImg.Width / 2), (int)(-turretImg.Height / 2) - 5, (int)(towers[i].energy / towerTypes[towers[i].type].maxEnergy * turretImg.Width), 3);
825
                        else if (towers[i].energy < towerTypes[towers[i].type].req)
826
                                g.FillRectangle(Brushes.Green, (int)(-turretImg.Width / 2), (int)(-turretImg.Height / 2) - 5, (int)(towers[i].energy / towerTypes[towers[i].type].maxEnergy * turretImg.Width), 3);
827
                        else
828
                                g.FillRectangle(Brushes.LawnGreen, (int)(-turretImg.Width / 2), (int)(-turretImg.Height / 2) - 5, (int)(towers[i].energy / towerTypes[towers[i].type].maxEnergy * turretImg.Width), 3);
829
                }
830
                g.RotateTransform(towers[i].angle);
831
                g.DrawImage(turretImg, (int)(-turretImg.Width / 2), (int)(-turretImg.Height / 2));
832
                g.ResetTransform();
833
            }
834
 
835
            // draw enemies
836
            for (int i = 0; i < enemies.Count; i++)
837
            {
838
                g.TranslateTransform(enemies[i].loc.X, enemies[i].loc.Y);
839
                g.RotateTransform(enemies[i].angle);
840
                g.DrawImage(getEnemyImg(i), (int)(-getEnemyImg(i).Width / 2), (int)(-getEnemyImg(i).Height / 2));
841
                g.ResetTransform();
842
            }
843
 
844
            //draw smoke
845
            for (int i = 0; i < smokes.Count; i++)
846
            {
847
                g.FillEllipse(new SolidBrush(Color.FromArgb(100, smokes[i].colour.R, smokes[i].colour.B, smokes[i].colour.G)), smokes[i].loc.X - (int)(smokes[i].time / 5), smokes[i].loc.Y - (int)(smokes[i].time / 5), smokes[i].time, smokes[i].time);
848
            }
849
 
850
            //draw energy flux!!
851
            for (int i  = 0; i < towers.Count; i++)
852
            {
853
                if (towers[i].fireing && towers[i].delayTime == towerTypes[towers[i].type].delay && towerTypes[towers[i].type].laserColour != null && towers[i].target != -1)
854
                {
855
                    g.FillEllipse(new SolidBrush(Color.FromArgb((int)(towers[i].glow / towerTypes[towers[i].type].maxEnergy * 100), towerTypes[towers[i].type].laserColour.R, towerTypes[towers[i].type].laserColour.B, towerTypes[towers[i].type].laserColour.G)), (int)(towers[i].loc.X - towers[i].glow / 2), (int)(towers[i].loc.Y - towers[i].glow / 2), towers[i].glow, towers[i].glow);
856
                }
857
            }
858
 
859
            Font font1 = new Font(FontFamily.GenericMonospace, 10, FontStyle.Regular, GraphicsUnit.Pixel);
860
 
861
                        StringFormat sf = new StringFormat();
862
                        sf.Alignment = StringAlignment.Center;
863
 
864
            //LOOSE TEXT
865
            if (lives <= 0)
866
                g.DrawString("You Loose!\nHAHAHA!", new Font(FontFamily.GenericMonospace, 40, FontStyle.Bold, GraphicsUnit.Pixel), new SolidBrush(controlFGColour), 250, 200, sf);
867
 
868
            if (detailText != "" && enemies.Count == 0)
869
                    g.DrawString(textWrap(font1, detailText, 450), font1, new SolidBrush(controlFGColour), 250, 400 - TextRenderer.MeasureText(textWrap(font1, detailText, 450), font1).Height, sf);
870
 
871
            view.Image = (Image)img.Clone();
872
            g.Dispose();
873
            img.Dispose();
874
 
875
            cashF.Refresh();
876
            livesF.Refresh();
877
            levelF.Refresh();
878
            view.Refresh();
879
 
880
        }
881
 
7 freddie 882
        public PointF[] rndmisePoints(PointF[] oldPoints, bool ignoreStartAndEnd)
883
        {
884
                PointF[] newPoints = oldPoints;
885
                if (ignoreStartAndEnd)
886
                {
887
                        for (int i = 1; i < newPoints.Length - 1; i++)
888
                                newPoints[i] = new PointF(oldPoints[i].X + (float)rnd.Next(-5, 6), oldPoints[i].Y + (float)rnd.Next(-5, 6));
889
                }
890
                else
891
                {
892
                        for (int i = 0; i < newPoints.Length; i++)
893
                                newPoints[i] = new PointF(oldPoints[i].X + (float)rnd.Next(-5, 6), oldPoints[i].Y + (float)rnd.Next(-5, 6));
894
                }
895
                return newPoints;
896
        }
897
 
1 freddie 898
        public string textWrap(Font font, string textN, int width)
899
        {
900
                string text = textN;
901
                int lastSpace = 1;
902
                for (int i = 1; i < text.Length; i++)
903
                {
904
                        if (text.Substring(i, 1) == " ")
905
                                lastSpace = i;
906
                        if (TextRenderer.MeasureText(text.Substring(0, i), font).Width > width)
907
                                text = text.Substring(0, lastSpace) + "\n" + text.Substring(lastSpace + 1);
908
                }
909
                return text;
910
        }
911
 
912
        public void drawBG()
913
        {
914
 
915
            Bitmap img = new Bitmap(500, 400);
916
            Graphics g = Graphics.FromImage(img);
917
 
918
            g.DrawImage(bgImg, 0, 0);
919
 
920
            Image baseImg;
921
            for (int i = 0; i < towers.Count; i++)
922
            {
923
                baseImg = getBaseImg(i);
924
                g.TranslateTransform(towers[i].loc.X, towers[i].loc.Y);
925
                g.DrawImage(baseImg, (int)(-baseImg.Width / 2), (int)(-baseImg.Height / 2));
926
                if (rangeRings)
927
                        g.DrawEllipse(new Pen(towerTypes[towers[i].type].laserColour, 3), -towerTypes[towers[i].type].range, -towerTypes[towers[i].type].range, towerTypes[towers[i].type].range * 2, towerTypes[towers[i].type].range * 2);
928
                g.ResetTransform();
929
            }
930
 
931
            view.BackgroundImage = (Image)img.Clone();
932
            g.Dispose();
933
            img.Dispose();
934
 
935
        }
936
 
937
        private void view_MouseClick(object sender, MouseEventArgs e)
938
        {
939
                if (e.Button == MouseButtons.Left)
940
                   {
941
                    if (cash >= towerTypes[selTowerType].cost)
942
                    {
943
                                for (int i = 0; i < towers.Count; i++)
944
                                {
945
                                        if (getDist(towers[i].loc, e.Location) < Math.Max(towerTypes[towers[i].type].baseImg.imgs[0].Width, towerTypes[towers[i].type].baseImg.imgs[0].Width) / 2 + Math.Max(towerTypes[selTowerType].baseImg.imgs[0].Width, towerTypes[selTowerType].baseImg.imgs[0].Width) / 2)
946
                                        {
947
                                        return;
948
                                        }
949
                                }
950
                        cash -= towerTypes[selTowerType].cost;
951
                        towers.Add(new tower(selTowerType, e.Location, towerTypes[selTowerType].sound));
952
                        drawBG();
953
                        draw();
954
                    }
955
                }
956
                else
957
                {
958
                        for (int i = 0; i < towers.Count; i++)
959
                        {
960
                                if (getDist(towers[i].loc, e.Location) < Math.Min(towerTypes[towers[i].type].baseImg.imgs[0].Width, towerTypes[towers[i].type].baseImg.imgs[0].Width) / 2)
961
                                {
962
                                        cash += (int)(towerTypes[towers[i].type].cost / 2);
963
                                        towers.RemoveAt(i);
964
                                        drawBG();
965
                                        draw();
966
                                        return;
967
                                }
968
                        }
969
                }
970
        }
971
 
972
        float getAngle(Point a, Point b)
973
        {
974
            if (a.X == b.X)
975
            {
976
                if (a.Y < b.Y)
977
                    return 90;
978
                else
979
                    return 270;
980
            }
981
            else if (a.Y == b.Y)
982
            {
983
                if (a.X < b.X)
984
                    return 0;
985
                else
986
                    return 180;
987
            }
988
            float output;
989
            output = (float)(Math.Atan((b.Y - a.Y) / (float)(b.X - a.X)) / Math.PI * 180.0f);
990
            if (a.X >= b.X)
991
                output += 180;
992
            if (output > 360)
993
                output -= 360;
994
            return output;
995
        }
996
 
997
        private void pictureBox1_Click(object sender, EventArgs e)
998
        {
999
            if (enemies.Count == 0)
1000
                newRun();
1001
        }
1002
 
1003
        public void initMove(int num)
1004
        {
1005
            enemies[num].dX = (float)Math.Cos(enemies[num].angle / 180 * Math.PI) * enemyTypes[enemies[num].type].speed;
1006
            enemies[num].dY = (float)Math.Sin(enemies[num].angle / 180 * Math.PI) * enemyTypes[enemies[num].type].speed;
1007
        }
1008
 
1009
        public void move(int num)
1010
        {
1011
                enemies[num].loc.X += enemies[num].dX;
1012
                enemies[num].loc.Y += enemies[num].dY;
1013
        }
1014
 
1015
        public void reTarget(int num)
1016
        {
1017
                bool res;
1018
                int tempEn;
1019
                if (towers[num].target != -1)
1020
                {
1021
                        tempEn = towers[num].target;
1022
                        towers[num].targets.Clear();
1023
                        towers[num].target = tempEn;
1024
                }
1025
                else
1026
                towers[num].targets.Clear();
1027
                for (int i = 0; i < enemies.Count; i++)
1028
            {
1029
                if (towerTypes[towers[num].type].laserType == 2 && towers[num].target != -1)
1030
                        res = enemies[i].loc.X >= 0 && getDist(FtoP(enemies[towers[num].targets[towers[num].targets.Count - 1]].loc), FtoP(enemies[i].loc)) <= towerTypes[towers[num].type].range && enemies[i].health > 0;
1031
                else
1032
                        res = enemies[i].loc.X >= 0 && getDist(towers[num].loc, FtoP(enemies[i].loc)) <= towerTypes[towers[num].type].range && enemies[i].health > 0;
1033
                if (res)
1034
                {
1035
                        if (towerTypes[towers[num].type].laserType == 2)
1036
                        {
1037
                                if (!towers[num].targets.Contains(i) || rnd.Next(0,2) == 0)
1038
                                        towers[num].targets.Add(i);
1039
                                if (rnd.Next(0, towerTypes[towers[num].type].killNum) == 0)
1040
                                                return;
1041
                        }
1042
                        else
1043
                        {
1044
                        towers[num].target = i;
1045
                        return;
1046
                        }
1047
                }
1048
            }
1049
            if (towerTypes[towers[num].type].laserType != 2)
1050
                towers[num].target = -1;
1051
        }
1052
 
1053
        public void reAngle(int num)
1054
        {
1055
                if (towers[num].target != -1)
1056
                towers[num].angle = (float)getAngle(towers[num].loc, new Point((int)enemies[towers[num].target].loc.X, (int)enemies[towers[num].target].loc.Y));
1057
        }
1058
 
1059
        public void fire(int num, bool fireing)
1060
        {
1061
                towers[num].fireing = fireing;
1062
//              towers[num].s.controls.stop();
1063
//              if (sound && fireing)
1064
//              {
1065
//                      if (towers[num].s.playState != WMPLib.WMPPlayState.wmppsPlaying)
1066
//                              towers[num].s.controls.play();
1067
//              }
1068
        }
1069
 
1070
        public Point FtoP(PointF point)
1071
        {
1072
            return new Point((int)point.X, (int)point.Y);
1073
        }
1074
 
1075
        public int getDist(Point a, Point b)
1076
        {
1077
            return (int)Math.Sqrt(Math.Abs((a.X - b.X) * (a.X - b.X)) + Math.Abs((a.Y - b.Y) * (a.Y - b.Y)));
1078
        }
1079
 
1080
        void IconPress(object sender, EventArgs e)
1081
        {
1082
                PictureBox icon = (PictureBox)sender;
1083
                if (towerTypes[(int)icon.Tag].cost <= cash)
1084
                {
1085
                        selTowerType = (int)icon.Tag;
1086
                        draw();
1087
                }
1088
        }
1089
 
1090
        void IconEnter(object sender, EventArgs e)
1091
        {
1092
                PictureBox icon = (PictureBox)sender;
1093
                if (towerTypes[(int)icon.Tag].laserType != -1)
1094
                        detailText = towerTypes[(int)icon.Tag].name + " - €" + towerTypes[(int)icon.Tag].cost + " - " + laserTypeLookup[towerTypes[(int)icon.Tag].laserType] + "\n" + towerTypes[(int)icon.Tag].details[lang];
1095
//              else
1096
//                      detailText = towerTypes[(int)icon.Tag].name + " - €" + towerTypes[(int)icon.Tag].cost + " - MType\n" + towerTypes[(int)icon.Tag].details;
1097
                        draw();
1098
        }
1099
 
1100
        void IconLeave(object sender, EventArgs e)
1101
        {
1102
                detailText = "";
1103
                draw();
1104
        }
1105
 
1106
        void Form1KeyDown(object sender, KeyEventArgs e)
1107
        {
1108
                switch (e.KeyCode)
1109
                {
1110
                        case Keys.Back:
1111
                                cash += 1000;
1112
                                break;
1113
                        case Keys.Space:
1114
                                energyBars = !energyBars;
1115
                                break;
1116
                        case Keys.Enter:
1117
                            if (enemies.Count == 0)
1118
                                        newRun();
1119
                                break;
1120
                        case Keys.Tab:
1121
                                autoRun = !autoRun;
1122
                                if (autoRun)
1123
                                        goF.BackgroundImage = noImg;
1124
                                else
1125
                                        goF.BackgroundImage = yesImg;
1126
                                break;
1127
                        case Keys.F8:
1128
                                level++;
1129
                                if (level >= levels.Length)
1130
                                        level = 0;
1131
                                break;
1132
                        case Keys.R:
1133
                                rangeRings = !rangeRings;
1134
                                drawBG();
1135
                                break;
1136
                        case Keys.F4:
1137
                                timer1.Enabled = !timer1.Enabled;
1138
                                break;
7 freddie 1139
                        case Keys.E:
1140
                                extraPretty = !extraPretty;
1141
                                break;
1 freddie 1142
//                      case Keys.S:
1143
//                              sound = !sound;
1144
//                              break;
1145
                        default:
1146
                                if (e.KeyCode.ToString().Length > 1)
1147
                                {
1148
                                        int res;
1149
                                        if (int.TryParse(e.KeyCode.ToString().Substring(1, 1), out res))
1150
                                        {
1151
                                                if (res < towerTypes.Count)
1152
                                                {
1153
                                                        if (cash >= towerTypes[res].cost)
1154
                                                                selTowerType = res;
1155
                                                }
1156
                                        }
1157
                                }
1158
                                break;
1159
                }
1160
                draw();
1161
 
1162
        }
1163
 
1164
        void Form1FormClosing(object sender, FormClosingEventArgs e)
1165
        {
1166
                autoRun = false;
1167
                Form2 menu = new Form2();
1168
                menu.Show();
1169
        }
1170
 
1171
        void Timer1Tick(object sender, EventArgs e)
1172
        {
1173
                this.Text = "Blockade! [" + (fCount * 2) + "FPS]";
1174
                fCount = 0;
1175
        }
1176
 
1177
        Image getBaseImg(int num)
1178
        {
1179
                if (towerTypes[towers[num].type].baseImg.maxRunTime < towers[num].baseTime)
1180
                        towers[num].baseTime = 0;
1181
                return towerTypes[towers[num].type].getBaseImg(towers[num].baseTime);
1182
        }
1183
 
1184
        Image getTurretImg(int num)
1185
        {
1186
                if (towerTypes[towers[num].type].turretImg.maxRunTime < towers[num].turretTime)
1187
                        towers[num].turretTime = 0;
1188
                return towerTypes[towers[num].type].getTurretImg(towers[num].turretTime);
1189
        }
1190
 
1191
        Image getEnemyImg(int num)
1192
        {
1193
                if (enemyTypes[enemies[num].type].img.maxRunTime < enemies[num].imgTime)
1194
                        enemies[num].imgTime = 0;
1195
                return enemyTypes[enemies[num].type].getImg(enemies[num].imgTime);
1196
        }
1197
    }
1198
}