Go to most recent revision | Details | 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 | |||
| 380 | Random rnd = new Random(); |
||
| 381 | |||
| 382 | public Form1(int language) |
||
| 383 | { |
||
| 384 | InitializeComponent(); |
||
| 385 | lang = language; |
||
| 386 | } |
||
| 387 | |||
| 388 | void mainLoop() |
||
| 389 | { |
||
| 390 | System.Threading.Thread.Sleep(1); |
||
| 391 | while (enemies.Count > 0) |
||
| 392 | { |
||
| 393 | fCount++; |
||
| 394 | Application.DoEvents(); |
||
| 395 | enemyLoop(); |
||
| 396 | towerLoop(); |
||
| 397 | missileLoop(); |
||
| 398 | smokeLoop(); |
||
| 399 | Application.DoEvents(); |
||
| 400 | draw(); |
||
| 401 | } |
||
| 402 | cash += (int)(lives / 2); |
||
| 403 | level++; |
||
| 404 | if (autoRun) |
||
| 405 | newRun(); |
||
| 406 | else |
||
| 407 | { |
||
| 408 | smokes.Clear(); |
||
| 409 | draw(); |
||
| 410 | } |
||
| 411 | } |
||
| 412 | |||
| 413 | void enemyLoop() |
||
| 414 | { |
||
| 415 | for (int i = enemies.Count - 1; i >= 0; i--) |
||
| 416 | { |
||
| 417 | enemies[i].incImg(); |
||
| 418 | if (enemies[i].health <= 0) |
||
| 419 | { |
||
| 420 | cash += enemyTypes[enemies[i].type].value; |
||
| 421 | if (enemyTypes[enemies[i].type].child == -1) |
||
| 422 | { |
||
| 423 | enemies.RemoveAt(i); |
||
| 424 | for (int j = 0; j < towers.Count; j++) |
||
| 425 | { |
||
| 426 | // loop removed |
||
| 427 | if (towers[j].target > i) |
||
| 428 | towers[j].target--; |
||
| 429 | else if (towers[j].target == i) |
||
| 430 | towers[j].target = -1; |
||
| 431 | } |
||
| 432 | } |
||
| 433 | else |
||
| 434 | { |
||
| 435 | enemies[i].type = enemyTypes[enemies[i].type].child; |
||
| 436 | enemies[i].health = enemyTypes[enemies[i].type].health; |
||
| 437 | initMove(i); |
||
| 438 | } |
||
| 439 | } |
||
| 440 | else |
||
| 441 | { |
||
| 442 | move(i); |
||
| 443 | if (enemyTypes[enemies[i].type].spawn != -1) |
||
| 444 | { |
||
| 445 | if (rnd.NextDouble() < enemyTypes[enemies[i].type].spawnChance) |
||
| 446 | { |
||
| 447 | 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)); |
||
| 448 | initMove(enemies.Count - 1); |
||
| 449 | } |
||
| 450 | } |
||
| 451 | if (enemies[i].loc.X > 500) |
||
| 452 | { |
||
| 453 | lives--; |
||
| 454 | enemies.RemoveAt(i); |
||
| 455 | for (int j = 0; j < towers.Count; j++) |
||
| 456 | { |
||
| 457 | // loop removed |
||
| 458 | if (towers[j].target > i) |
||
| 459 | towers[j].target--; |
||
| 460 | else if (towers[j].target == i) |
||
| 461 | towers[j].target = -1; |
||
| 462 | } |
||
| 463 | } |
||
| 464 | } |
||
| 465 | } |
||
| 466 | } |
||
| 467 | |||
| 468 | void towerLoop() |
||
| 469 | { |
||
| 470 | for (int i = 0; i < towers.Count; i++) |
||
| 471 | { |
||
| 472 | towers[i].incImgs(); |
||
| 473 | if (towers[i].glow > 0) |
||
| 474 | towers[i].glow--; |
||
| 475 | if (towers[i].delayTime != 0) |
||
| 476 | towers[i].delayTime--; |
||
| 477 | |||
| 478 | if (towers[i].target == -1 || getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) > towerTypes[towers[i].type].range) |
||
| 479 | { |
||
| 480 | towers[i].target = -1; |
||
| 481 | reTarget(i); |
||
| 482 | } |
||
| 483 | else if (towerTypes[towers[i].type].req != 0 && towers[i].energy >= towerTypes[towers[i].type].req) |
||
| 484 | { |
||
| 485 | if (towerTypes[towers[i].type].laserType == 2) |
||
| 486 | reTarget(i); |
||
| 487 | fire(i, true); |
||
| 488 | } |
||
| 489 | reAngle(i); |
||
| 490 | if (towers[i].fireing && towers[i].target != -1 && towers[i].energy >= towerTypes[towers[i].type].useRate) |
||
| 491 | { |
||
| 492 | // towers[i].s.controls.play(); |
||
| 493 | if (towerTypes[towers[i].type].laserColour == null) |
||
| 494 | { |
||
| 495 | } |
||
| 496 | else if (towers[i].delayTime == 0) |
||
| 497 | { |
||
| 498 | towers[i].energy -= towerTypes[towers[i].type].useRate; |
||
| 499 | int smokeSpreadWidth = (int)(getEnemyImg(towers[i].target).Width / 3); |
||
| 500 | int smokeSpreadHeight = (int)(getEnemyImg(towers[i].target).Height / 3); |
||
| 501 | int num = rnd.Next(1, (int)(towerTypes[towers[i].type].useRate / 100 + 2)); |
||
| 502 | switch (towerTypes[towers[i].type].laserType) |
||
| 503 | { |
||
| 504 | case (0): |
||
| 505 | { |
||
| 506 | enemies[towers[i].target].health -= towerTypes[towers[i].type].damage; |
||
| 507 | for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 + 0.5); j++) |
||
| 508 | 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)); |
||
| 509 | break; |
||
| 510 | } |
||
| 511 | case (1): |
||
| 512 | { |
||
| 513 | enemies[towers[i].target].health -= towerTypes[towers[i].type].damage; |
||
| 514 | for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 + 0.5); j++) |
||
| 515 | 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)); |
||
| 516 | break; |
||
| 517 | } |
||
| 518 | case (2): |
||
| 519 | { |
||
| 520 | for (int r = 0; r < towers[i].targets.Count; r++) |
||
| 521 | { |
||
| 522 | enemies[towers[i].targets[r]].health -= towerTypes[towers[i].type].damage / (float)towers[i].targets.Count; |
||
| 523 | for (int j = 0; j < (int)(num * smokeMul + rnd.NextDouble() * 1.5 / (float)towers[i].targets.Count + 0.5); j++) |
||
| 524 | 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)); |
||
| 525 | } |
||
| 526 | break; |
||
| 527 | } |
||
| 528 | } |
||
| 529 | towers[i].glow = towerTypes[towers[i].type].useRate; |
||
| 530 | towers[i].delayTime += towerTypes[towers[i].type].delay; |
||
| 531 | } |
||
| 532 | } |
||
| 533 | else |
||
| 534 | { |
||
| 535 | fire(i, false); |
||
| 536 | towers[i].energy += towerTypes[towers[i].type].gainRate - rnd.Next(0, (int)Math.Ceiling((towerTypes[towers[i].type].gainRate / 5))); |
||
| 537 | if (towers[i].energy >= towerTypes[towers[i].type].maxEnergy && towers[i].target != -1) |
||
| 538 | { |
||
| 539 | towers[i].energy = towerTypes[towers[i].type].maxEnergy; |
||
| 540 | } |
||
| 541 | } |
||
| 542 | if (towers[i].energy > towerTypes[towers[i].type].maxEnergy) |
||
| 543 | towers[i].energy = towerTypes[towers[i].type].maxEnergy; |
||
| 544 | } |
||
| 545 | } |
||
| 546 | |||
| 547 | void missileLoop() |
||
| 548 | { |
||
| 549 | |||
| 550 | } |
||
| 551 | |||
| 552 | void smokeLoop() |
||
| 553 | { |
||
| 554 | for (int i = smokes.Count - 1; i >= 0 ; i--) |
||
| 555 | { |
||
| 556 | smokes[i].time--; |
||
| 557 | if (smokes[i].time <= 0) |
||
| 558 | smokes.RemoveAt(i); |
||
| 559 | } |
||
| 560 | } |
||
| 561 | |||
| 562 | void newRun() |
||
| 563 | { |
||
| 564 | if (level >= levels.Length) |
||
| 565 | { |
||
| 566 | level = 0; |
||
| 567 | for (int i = 0; i < enemyTypes.Count; i++) |
||
| 568 | { |
||
| 569 | enemyTypes[i].health *= 1.2f; |
||
| 570 | } |
||
| 571 | } |
||
| 572 | string[] data = levels[level].Split(','); |
||
| 573 | PointF start; |
||
| 574 | Point end; |
||
| 575 | for (int i = 0; i < data.Length; i++) |
||
| 576 | { |
||
| 577 | start = new PointF(rnd.Next(-150, -55), rnd.Next(40, 360)); |
||
| 578 | end = new Point(500, rnd.Next(40, 360)); |
||
| 579 | enemies.Add(new enemy(int.Parse(data[i]), enemyTypes[int.Parse(data[i])].health, (float)getAngle(FtoP(start), end), start)); |
||
| 580 | initMove(enemies.Count - 1); |
||
| 581 | enemies[enemies.Count - 1].imgTime = rnd.Next(enemyTypes[enemies[enemies.Count - 1].type].img.maxRunTime); |
||
| 582 | } |
||
| 583 | mainLoop(); |
||
| 584 | } |
||
| 585 | |||
| 586 | private void Form1_Load(object sender, EventArgs e) |
||
| 587 | { |
||
| 588 | initAll(); |
||
| 589 | } |
||
| 590 | |||
| 591 | public void initAll() |
||
| 592 | { |
||
| 593 | |||
| 594 | // handels |
||
| 595 | |||
| 596 | System.IO.StreamReader reader; |
||
| 597 | string r; |
||
| 598 | string[] lines; |
||
| 599 | |||
| 600 | // textLookUps |
||
| 601 | |||
| 602 | reader = new System.IO.StreamReader(@"data/gameTexts.dat", Encoding.UTF8); |
||
| 603 | lines = reader.ReadToEnd().Split('\n'); |
||
| 604 | |||
| 605 | laserType0 = lines[0].Split(':'); |
||
| 606 | laserType1 = lines[1].Split(':'); |
||
| 607 | laserType2 = lines[2].Split(':'); |
||
| 608 | cashA = lines[3].Split(':'); |
||
| 609 | livesA = lines[4].Split(':'); |
||
| 610 | levelA = lines[5].Split(':'); |
||
| 611 | |||
| 612 | laserTypeLookup = new String[3]; |
||
| 613 | laserTypeLookup[0] = laserType0[lang]; |
||
| 614 | laserTypeLookup[1] = laserType1[lang]; |
||
| 615 | laserTypeLookup[2] = laserType2[lang]; |
||
| 616 | |||
| 617 | // init start vars |
||
| 618 | |||
| 619 | reader = new System.IO.StreamReader(@"data/start.dat", Encoding.UTF8); |
||
| 620 | r = reader.ReadToEnd(); |
||
| 621 | reader.Close(); |
||
| 622 | string[] data = r.Split(','); |
||
| 623 | cash = int.Parse(data[0]); |
||
| 624 | lives = int.Parse(data[1]); |
||
| 625 | bgImg = Image.FromFile(@"data/" + data[2]); |
||
| 626 | beamF.Image = Image.FromFile(@"data/" + data[3]); |
||
| 627 | smokeMul = float.Parse(data[4]); |
||
| 628 | controlBGColour = Color.FromName(data[5]); |
||
| 629 | controlFGColour = Color.FromName(data[6]); |
||
| 630 | |||
| 631 | // basic UI stuff |
||
| 632 | |||
| 633 | this.Text = "Blockade!"; |
||
| 634 | yesImg = Image.FromFile(@"data/yesImg.png"); |
||
| 635 | noImg = Image.FromFile(@"data/noImg.png"); |
||
| 636 | selImg = Image.FromFile(@"data/selImg.png"); |
||
| 637 | goF.BackColor = controlBGColour; |
||
| 638 | goF.BackgroundImage = yesImg; |
||
| 639 | goF.Image = Image.FromFile(@"data/go.png"); |
||
| 640 | cashF.BackColor = controlBGColour; |
||
| 641 | livesF.BackColor = controlBGColour; |
||
| 642 | levelF.BackColor = controlBGColour; |
||
| 643 | cashF.ForeColor = controlFGColour; |
||
| 644 | livesF.ForeColor = controlFGColour; |
||
| 645 | levelF.ForeColor = controlFGColour; |
||
| 646 | |||
| 647 | |||
| 648 | // load ingame object types |
||
| 649 | |||
| 650 | reader = new System.IO.StreamReader(@"data/enemies.dat", Encoding.UTF8); |
||
| 651 | r = reader.ReadToEnd(); |
||
| 652 | reader.Close(); |
||
| 653 | lines = r.Split('\n'); |
||
| 654 | for (int i = 0; i < lines.Length; i++) |
||
| 655 | { |
||
| 656 | if (lines[i].Length != 0 && lines[i].Substring(0,1) != "#") |
||
| 657 | enemyTypes.Add(new enemyType(lines[i].Split(','))); |
||
| 658 | } |
||
| 659 | |||
| 660 | reader = new System.IO.StreamReader(@"data/missiles.dat", Encoding.UTF8); |
||
| 661 | r = reader.ReadToEnd(); |
||
| 662 | reader.Close(); |
||
| 663 | lines = r.Split('\n'); |
||
| 664 | for (int i = 0; i < lines.Length; i++) |
||
| 665 | { |
||
| 666 | if (lines[i].Length != 0 && lines[i].Substring(0,1) != "#") |
||
| 667 | missileTypes.Add(new missileType(lines[i].Split(','))); |
||
| 668 | } |
||
| 669 | |||
| 670 | reader = new System.IO.StreamReader(@"data/towers.dat", Encoding.UTF8); |
||
| 671 | r = reader.ReadToEnd(); |
||
| 672 | reader.Close(); |
||
| 673 | lines = r.Split('\n'); |
||
| 674 | for (int i = 0; i < lines.Length; i++) |
||
| 675 | { |
||
| 676 | if (lines[i].Length != 0 && lines[i].Substring(0, 1) != "#") |
||
| 677 | towerTypes.Add(new towerType(lines[i].Split(','))); |
||
| 678 | } |
||
| 679 | |||
| 680 | // load levels |
||
| 681 | |||
| 682 | reader = new System.IO.StreamReader(@"data/levels.dat"); |
||
| 683 | r = reader.ReadToEnd(); |
||
| 684 | reader.Close(); |
||
| 685 | levels = r.Split('\n'); |
||
| 686 | |||
| 687 | // set up Icons |
||
| 688 | |||
| 689 | Point iconLoc = new Point(); |
||
| 690 | |||
| 691 | for (int i = 0; i < towerTypes.Count; i++) |
||
| 692 | { |
||
| 693 | icons.Add(new PictureBox()); |
||
| 694 | icons[i].BackColor = controlBGColour; |
||
| 695 | icons[i].SizeMode = PictureBoxSizeMode.Zoom; |
||
| 696 | icons[i].Image = towerTypes[i].turretImg.imgs[0]; |
||
| 697 | iconLoc.X = 150 + (int)Math.Floor(i / 2.0) * 48; |
||
| 698 | icons[i].Visible = true; |
||
| 699 | icons[i].Click += new EventHandler(IconPress); |
||
| 700 | if ((float)Math.Floor(i / 2.0) != (float)(i / 2.0)) |
||
| 701 | iconLoc.Y = 454; |
||
| 702 | else |
||
| 703 | iconLoc.Y = 408; |
||
| 704 | icons[i].Location = iconLoc; |
||
| 705 | icons[i].Tag = i; |
||
| 706 | icons[i].Size = new Size(40, 40); |
||
| 707 | icons[i].MouseHover += new EventHandler(IconEnter); |
||
| 708 | icons[i].MouseLeave += new EventHandler(IconLeave); |
||
| 709 | Controls.Add(icons[i]); |
||
| 710 | icons[i].BringToFront(); |
||
| 711 | icons[i].Refresh(); |
||
| 712 | } |
||
| 713 | |||
| 714 | // close reader |
||
| 715 | |||
| 716 | reader.Close(); |
||
| 717 | |||
| 718 | // Draw everything... |
||
| 719 | |||
| 720 | drawBG(); |
||
| 721 | draw(); |
||
| 722 | |||
| 723 | } |
||
| 724 | |||
| 725 | public float notZero(float value) |
||
| 726 | { |
||
| 727 | if (value == 0) |
||
| 728 | return 0.01f; |
||
| 729 | else |
||
| 730 | return value; |
||
| 731 | } |
||
| 732 | |||
| 733 | public void draw() |
||
| 734 | { |
||
| 735 | |||
| 736 | for (int i = 0; i < icons.Count; i++) |
||
| 737 | { |
||
| 738 | if (cash < towerTypes[i].cost) |
||
| 739 | icons[i].BackgroundImage = noImg; |
||
| 740 | else if (selTowerType == i) |
||
| 741 | icons[i].BackgroundImage = selImg; |
||
| 742 | else |
||
| 743 | icons[i].BackgroundImage = yesImg; |
||
| 744 | } |
||
| 745 | |||
| 746 | cashF.Text = cashA[lang] + ": " + cash.ToString(); |
||
| 747 | livesF.Text = lives.ToString() + " " + livesA[lang]; |
||
| 748 | levelF.Text = levelA[lang] + ": " + level.ToString(); |
||
| 749 | |||
| 750 | Bitmap img = new Bitmap(500, 400); |
||
| 751 | Graphics g = Graphics.FromImage(img); |
||
| 752 | PointF[] points; |
||
| 753 | |||
| 754 | // draw towers |
||
| 755 | Image baseImg, turretImg; |
||
| 756 | for (int i = 0; i < towers.Count; i++) |
||
| 757 | { |
||
| 758 | baseImg = getBaseImg(i); |
||
| 759 | turretImg = getTurretImg(i); |
||
| 760 | if (towers[i].fireing && towers[i].delayTime == towerTypes[towers[i].type].delay && towerTypes[towers[i].type].laserColour != null && towers[i].target != -1) |
||
| 761 | { |
||
| 762 | switch (towerTypes[towers[i].type].laserType) |
||
| 763 | { |
||
| 764 | case (0): |
||
| 765 | { |
||
| 766 | g.DrawLine(new Pen(towerTypes[towers[i].type].laserColour, 3), (PointF)towers[i].loc, enemies[towers[i].target].loc); |
||
| 767 | break; |
||
| 768 | } |
||
| 769 | case (1): |
||
| 770 | { |
||
| 771 | //laser |
||
| 772 | points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) / 50 + 3]; |
||
| 773 | points[0] = enemies[towers[i].target].loc; |
||
| 774 | points[points.Length - 1] = towers[i].loc; |
||
| 775 | for (int j = 1; j < points.Length - 1; j++) |
||
| 776 | 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)); |
||
| 777 | g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points); |
||
| 778 | // //impactThing |
||
| 779 | // points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) / 50 + 3]; |
||
| 780 | // points[0] = enemies[towers[i].target].loc; |
||
| 781 | // points[points.Length - 1] = enemies[towers[i].target].loc; |
||
| 782 | // for (int j = 1; j < points.Length - 1; j++) |
||
| 783 | // points[j] = new PointF((int)enemies[towers[i].target].loc.X + rnd.Next(-(int)(enemyTypes[enemies[towers[i].target].type].img.imgs[0].Width * 0.8), (int)(enemyTypes[enemies[towers[i].target].type].img.imgs[0].Width * 0.8)), (int)enemies[towers[i].target].loc.Y + rnd.Next(-(int)(enemyTypes[enemies[towers[i].target].type].img.imgs[0].Height * 0.8), (int)(enemyTypes[enemies[towers[i].target].type].img.imgs[0].Height * 0.8))); |
||
| 784 | // g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points); |
||
| 785 | break; |
||
| 786 | } |
||
| 787 | case (2): |
||
| 788 | { |
||
| 789 | //initialLaser |
||
| 790 | points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].target].loc)) / 50 + 3]; |
||
| 791 | points[0] = enemies[towers[i].target].loc; |
||
| 792 | points[points.Length - 1] = towers[i].loc; |
||
| 793 | for (int j = 1; j < points.Length - 1; j++) |
||
| 794 | 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)); |
||
| 795 | g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points); |
||
| 796 | //furtherLasers |
||
| 797 | for (int r = 1; r < towers[i].targets.Count; r++) |
||
| 798 | { |
||
| 799 | points = new PointF[getDist(towers[i].loc, FtoP(enemies[towers[i].targets[r]].loc)) / 50 + 3]; |
||
| 800 | points[0] = enemies[towers[i].targets[r]].loc; |
||
| 801 | points[points.Length - 1] = enemies[towers[i].targets[r - 1]].loc; |
||
| 802 | for (int j = 1; j < points.Length - 1; j++) |
||
| 803 | 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)); |
||
| 804 | g.DrawLines(new Pen(towerTypes[towers[i].type].laserColour, 3), points); |
||
| 805 | } |
||
| 806 | break; |
||
| 807 | } |
||
| 808 | } |
||
| 809 | } |
||
| 810 | |||
| 811 | g.TranslateTransform(towers[i].loc.X, towers[i].loc.Y); |
||
| 812 | if (energyBars) |
||
| 813 | { |
||
| 814 | if (towers[i].fireing) |
||
| 815 | 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); |
||
| 816 | else if (towers[i].energy < towerTypes[towers[i].type].req) |
||
| 817 | 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); |
||
| 818 | else |
||
| 819 | 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); |
||
| 820 | } |
||
| 821 | g.RotateTransform(towers[i].angle); |
||
| 822 | g.DrawImage(turretImg, (int)(-turretImg.Width / 2), (int)(-turretImg.Height / 2)); |
||
| 823 | g.ResetTransform(); |
||
| 824 | } |
||
| 825 | |||
| 826 | // draw enemies |
||
| 827 | for (int i = 0; i < enemies.Count; i++) |
||
| 828 | { |
||
| 829 | g.TranslateTransform(enemies[i].loc.X, enemies[i].loc.Y); |
||
| 830 | g.RotateTransform(enemies[i].angle); |
||
| 831 | g.DrawImage(getEnemyImg(i), (int)(-getEnemyImg(i).Width / 2), (int)(-getEnemyImg(i).Height / 2)); |
||
| 832 | g.ResetTransform(); |
||
| 833 | } |
||
| 834 | |||
| 835 | //draw smoke |
||
| 836 | for (int i = 0; i < smokes.Count; i++) |
||
| 837 | { |
||
| 838 | 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); |
||
| 839 | } |
||
| 840 | |||
| 841 | //draw energy flux!! |
||
| 842 | for (int i = 0; i < towers.Count; i++) |
||
| 843 | { |
||
| 844 | if (towers[i].fireing && towers[i].delayTime == towerTypes[towers[i].type].delay && towerTypes[towers[i].type].laserColour != null && towers[i].target != -1) |
||
| 845 | { |
||
| 846 | 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); |
||
| 847 | } |
||
| 848 | } |
||
| 849 | |||
| 850 | Font font1 = new Font(FontFamily.GenericMonospace, 10, FontStyle.Regular, GraphicsUnit.Pixel); |
||
| 851 | |||
| 852 | StringFormat sf = new StringFormat(); |
||
| 853 | sf.Alignment = StringAlignment.Center; |
||
| 854 | |||
| 855 | //LOOSE TEXT |
||
| 856 | if (lives <= 0) |
||
| 857 | g.DrawString("You Loose!\nHAHAHA!", new Font(FontFamily.GenericMonospace, 40, FontStyle.Bold, GraphicsUnit.Pixel), new SolidBrush(controlFGColour), 250, 200, sf); |
||
| 858 | |||
| 859 | if (detailText != "" && enemies.Count == 0) |
||
| 860 | g.DrawString(textWrap(font1, detailText, 450), font1, new SolidBrush(controlFGColour), 250, 400 - TextRenderer.MeasureText(textWrap(font1, detailText, 450), font1).Height, sf); |
||
| 861 | |||
| 862 | view.Image = (Image)img.Clone(); |
||
| 863 | g.Dispose(); |
||
| 864 | img.Dispose(); |
||
| 865 | |||
| 866 | cashF.Refresh(); |
||
| 867 | livesF.Refresh(); |
||
| 868 | levelF.Refresh(); |
||
| 869 | view.Refresh(); |
||
| 870 | |||
| 871 | } |
||
| 872 | |||
| 873 | public string textWrap(Font font, string textN, int width) |
||
| 874 | { |
||
| 875 | string text = textN; |
||
| 876 | int lastSpace = 1; |
||
| 877 | for (int i = 1; i < text.Length; i++) |
||
| 878 | { |
||
| 879 | if (text.Substring(i, 1) == " ") |
||
| 880 | lastSpace = i; |
||
| 881 | if (TextRenderer.MeasureText(text.Substring(0, i), font).Width > width) |
||
| 882 | text = text.Substring(0, lastSpace) + "\n" + text.Substring(lastSpace + 1); |
||
| 883 | } |
||
| 884 | return text; |
||
| 885 | } |
||
| 886 | |||
| 887 | public void drawBG() |
||
| 888 | { |
||
| 889 | |||
| 890 | Bitmap img = new Bitmap(500, 400); |
||
| 891 | Graphics g = Graphics.FromImage(img); |
||
| 892 | |||
| 893 | g.DrawImage(bgImg, 0, 0); |
||
| 894 | |||
| 895 | Image baseImg; |
||
| 896 | for (int i = 0; i < towers.Count; i++) |
||
| 897 | { |
||
| 898 | baseImg = getBaseImg(i); |
||
| 899 | g.TranslateTransform(towers[i].loc.X, towers[i].loc.Y); |
||
| 900 | g.DrawImage(baseImg, (int)(-baseImg.Width / 2), (int)(-baseImg.Height / 2)); |
||
| 901 | if (rangeRings) |
||
| 902 | 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); |
||
| 903 | g.ResetTransform(); |
||
| 904 | } |
||
| 905 | |||
| 906 | view.BackgroundImage = (Image)img.Clone(); |
||
| 907 | g.Dispose(); |
||
| 908 | img.Dispose(); |
||
| 909 | |||
| 910 | } |
||
| 911 | |||
| 912 | private void view_MouseClick(object sender, MouseEventArgs e) |
||
| 913 | { |
||
| 914 | if (e.Button == MouseButtons.Left) |
||
| 915 | { |
||
| 916 | if (cash >= towerTypes[selTowerType].cost) |
||
| 917 | { |
||
| 918 | for (int i = 0; i < towers.Count; i++) |
||
| 919 | { |
||
| 920 | 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) |
||
| 921 | { |
||
| 922 | return; |
||
| 923 | } |
||
| 924 | } |
||
| 925 | cash -= towerTypes[selTowerType].cost; |
||
| 926 | towers.Add(new tower(selTowerType, e.Location, towerTypes[selTowerType].sound)); |
||
| 927 | drawBG(); |
||
| 928 | draw(); |
||
| 929 | } |
||
| 930 | } |
||
| 931 | else |
||
| 932 | { |
||
| 933 | for (int i = 0; i < towers.Count; i++) |
||
| 934 | { |
||
| 935 | 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) |
||
| 936 | { |
||
| 937 | cash += (int)(towerTypes[towers[i].type].cost / 2); |
||
| 938 | towers.RemoveAt(i); |
||
| 939 | drawBG(); |
||
| 940 | draw(); |
||
| 941 | return; |
||
| 942 | } |
||
| 943 | } |
||
| 944 | } |
||
| 945 | } |
||
| 946 | |||
| 947 | float getAngle(Point a, Point b) |
||
| 948 | { |
||
| 949 | if (a.X == b.X) |
||
| 950 | { |
||
| 951 | if (a.Y < b.Y) |
||
| 952 | return 90; |
||
| 953 | else |
||
| 954 | return 270; |
||
| 955 | } |
||
| 956 | else if (a.Y == b.Y) |
||
| 957 | { |
||
| 958 | if (a.X < b.X) |
||
| 959 | return 0; |
||
| 960 | else |
||
| 961 | return 180; |
||
| 962 | } |
||
| 963 | float output; |
||
| 964 | output = (float)(Math.Atan((b.Y - a.Y) / (float)(b.X - a.X)) / Math.PI * 180.0f); |
||
| 965 | if (a.X >= b.X) |
||
| 966 | output += 180; |
||
| 967 | if (output > 360) |
||
| 968 | output -= 360; |
||
| 969 | return output; |
||
| 970 | } |
||
| 971 | |||
| 972 | private void pictureBox1_Click(object sender, EventArgs e) |
||
| 973 | { |
||
| 974 | if (enemies.Count == 0) |
||
| 975 | newRun(); |
||
| 976 | } |
||
| 977 | |||
| 978 | public void initMove(int num) |
||
| 979 | { |
||
| 980 | enemies[num].dX = (float)Math.Cos(enemies[num].angle / 180 * Math.PI) * enemyTypes[enemies[num].type].speed; |
||
| 981 | enemies[num].dY = (float)Math.Sin(enemies[num].angle / 180 * Math.PI) * enemyTypes[enemies[num].type].speed; |
||
| 982 | } |
||
| 983 | |||
| 984 | public void move(int num) |
||
| 985 | { |
||
| 986 | enemies[num].loc.X += enemies[num].dX; |
||
| 987 | enemies[num].loc.Y += enemies[num].dY; |
||
| 988 | } |
||
| 989 | |||
| 990 | public void reTarget(int num) |
||
| 991 | { |
||
| 992 | bool res; |
||
| 993 | int tempEn; |
||
| 994 | if (towers[num].target != -1) |
||
| 995 | { |
||
| 996 | tempEn = towers[num].target; |
||
| 997 | towers[num].targets.Clear(); |
||
| 998 | towers[num].target = tempEn; |
||
| 999 | } |
||
| 1000 | else |
||
| 1001 | towers[num].targets.Clear(); |
||
| 1002 | for (int i = 0; i < enemies.Count; i++) |
||
| 1003 | { |
||
| 1004 | if (towerTypes[towers[num].type].laserType == 2 && towers[num].target != -1) |
||
| 1005 | 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; |
||
| 1006 | else |
||
| 1007 | res = enemies[i].loc.X >= 0 && getDist(towers[num].loc, FtoP(enemies[i].loc)) <= towerTypes[towers[num].type].range && enemies[i].health > 0; |
||
| 1008 | if (res) |
||
| 1009 | { |
||
| 1010 | if (towerTypes[towers[num].type].laserType == 2) |
||
| 1011 | { |
||
| 1012 | if (!towers[num].targets.Contains(i) || rnd.Next(0,2) == 0) |
||
| 1013 | towers[num].targets.Add(i); |
||
| 1014 | if (rnd.Next(0, towerTypes[towers[num].type].killNum) == 0) |
||
| 1015 | return; |
||
| 1016 | } |
||
| 1017 | else |
||
| 1018 | { |
||
| 1019 | towers[num].target = i; |
||
| 1020 | return; |
||
| 1021 | } |
||
| 1022 | } |
||
| 1023 | } |
||
| 1024 | if (towerTypes[towers[num].type].laserType != 2) |
||
| 1025 | towers[num].target = -1; |
||
| 1026 | } |
||
| 1027 | |||
| 1028 | public void reAngle(int num) |
||
| 1029 | { |
||
| 1030 | if (towers[num].target != -1) |
||
| 1031 | towers[num].angle = (float)getAngle(towers[num].loc, new Point((int)enemies[towers[num].target].loc.X, (int)enemies[towers[num].target].loc.Y)); |
||
| 1032 | } |
||
| 1033 | |||
| 1034 | public void fire(int num, bool fireing) |
||
| 1035 | { |
||
| 1036 | towers[num].fireing = fireing; |
||
| 1037 | // towers[num].s.controls.stop(); |
||
| 1038 | // if (sound && fireing) |
||
| 1039 | // { |
||
| 1040 | // if (towers[num].s.playState != WMPLib.WMPPlayState.wmppsPlaying) |
||
| 1041 | // towers[num].s.controls.play(); |
||
| 1042 | // } |
||
| 1043 | } |
||
| 1044 | |||
| 1045 | public Point FtoP(PointF point) |
||
| 1046 | { |
||
| 1047 | return new Point((int)point.X, (int)point.Y); |
||
| 1048 | } |
||
| 1049 | |||
| 1050 | public int getDist(Point a, Point b) |
||
| 1051 | { |
||
| 1052 | return (int)Math.Sqrt(Math.Abs((a.X - b.X) * (a.X - b.X)) + Math.Abs((a.Y - b.Y) * (a.Y - b.Y))); |
||
| 1053 | } |
||
| 1054 | |||
| 1055 | void IconPress(object sender, EventArgs e) |
||
| 1056 | { |
||
| 1057 | PictureBox icon = (PictureBox)sender; |
||
| 1058 | if (towerTypes[(int)icon.Tag].cost <= cash) |
||
| 1059 | { |
||
| 1060 | selTowerType = (int)icon.Tag; |
||
| 1061 | draw(); |
||
| 1062 | } |
||
| 1063 | } |
||
| 1064 | |||
| 1065 | void IconEnter(object sender, EventArgs e) |
||
| 1066 | { |
||
| 1067 | PictureBox icon = (PictureBox)sender; |
||
| 1068 | if (towerTypes[(int)icon.Tag].laserType != -1) |
||
| 1069 | detailText = towerTypes[(int)icon.Tag].name + " - €" + towerTypes[(int)icon.Tag].cost + " - " + laserTypeLookup[towerTypes[(int)icon.Tag].laserType] + "\n" + towerTypes[(int)icon.Tag].details[lang]; |
||
| 1070 | // else |
||
| 1071 | // detailText = towerTypes[(int)icon.Tag].name + " - €" + towerTypes[(int)icon.Tag].cost + " - MType\n" + towerTypes[(int)icon.Tag].details; |
||
| 1072 | draw(); |
||
| 1073 | } |
||
| 1074 | |||
| 1075 | void IconLeave(object sender, EventArgs e) |
||
| 1076 | { |
||
| 1077 | detailText = ""; |
||
| 1078 | draw(); |
||
| 1079 | } |
||
| 1080 | |||
| 1081 | void Form1KeyDown(object sender, KeyEventArgs e) |
||
| 1082 | { |
||
| 1083 | switch (e.KeyCode) |
||
| 1084 | { |
||
| 1085 | case Keys.Back: |
||
| 1086 | cash += 1000; |
||
| 1087 | break; |
||
| 1088 | case Keys.Space: |
||
| 1089 | energyBars = !energyBars; |
||
| 1090 | break; |
||
| 1091 | case Keys.Enter: |
||
| 1092 | if (enemies.Count == 0) |
||
| 1093 | newRun(); |
||
| 1094 | break; |
||
| 1095 | case Keys.Tab: |
||
| 1096 | autoRun = !autoRun; |
||
| 1097 | if (autoRun) |
||
| 1098 | goF.BackgroundImage = noImg; |
||
| 1099 | else |
||
| 1100 | goF.BackgroundImage = yesImg; |
||
| 1101 | break; |
||
| 1102 | case Keys.F8: |
||
| 1103 | level++; |
||
| 1104 | if (level >= levels.Length) |
||
| 1105 | level = 0; |
||
| 1106 | break; |
||
| 1107 | case Keys.R: |
||
| 1108 | rangeRings = !rangeRings; |
||
| 1109 | drawBG(); |
||
| 1110 | break; |
||
| 1111 | case Keys.F4: |
||
| 1112 | timer1.Enabled = !timer1.Enabled; |
||
| 1113 | break; |
||
| 1114 | // case Keys.S: |
||
| 1115 | // sound = !sound; |
||
| 1116 | // break; |
||
| 1117 | default: |
||
| 1118 | if (e.KeyCode.ToString().Length > 1) |
||
| 1119 | { |
||
| 1120 | int res; |
||
| 1121 | if (int.TryParse(e.KeyCode.ToString().Substring(1, 1), out res)) |
||
| 1122 | { |
||
| 1123 | if (res < towerTypes.Count) |
||
| 1124 | { |
||
| 1125 | if (cash >= towerTypes[res].cost) |
||
| 1126 | selTowerType = res; |
||
| 1127 | } |
||
| 1128 | } |
||
| 1129 | } |
||
| 1130 | break; |
||
| 1131 | } |
||
| 1132 | draw(); |
||
| 1133 | |||
| 1134 | } |
||
| 1135 | |||
| 1136 | void Form1FormClosing(object sender, FormClosingEventArgs e) |
||
| 1137 | { |
||
| 1138 | autoRun = false; |
||
| 1139 | Form2 menu = new Form2(); |
||
| 1140 | menu.Show(); |
||
| 1141 | } |
||
| 1142 | |||
| 1143 | void Timer1Tick(object sender, EventArgs e) |
||
| 1144 | { |
||
| 1145 | this.Text = "Blockade! [" + (fCount * 2) + "FPS]"; |
||
| 1146 | fCount = 0; |
||
| 1147 | } |
||
| 1148 | |||
| 1149 | Image getBaseImg(int num) |
||
| 1150 | { |
||
| 1151 | if (towerTypes[towers[num].type].baseImg.maxRunTime < towers[num].baseTime) |
||
| 1152 | towers[num].baseTime = 0; |
||
| 1153 | return towerTypes[towers[num].type].getBaseImg(towers[num].baseTime); |
||
| 1154 | } |
||
| 1155 | |||
| 1156 | Image getTurretImg(int num) |
||
| 1157 | { |
||
| 1158 | if (towerTypes[towers[num].type].turretImg.maxRunTime < towers[num].turretTime) |
||
| 1159 | towers[num].turretTime = 0; |
||
| 1160 | return towerTypes[towers[num].type].getTurretImg(towers[num].turretTime); |
||
| 1161 | } |
||
| 1162 | |||
| 1163 | Image getEnemyImg(int num) |
||
| 1164 | { |
||
| 1165 | if (enemyTypes[enemies[num].type].img.maxRunTime < enemies[num].imgTime) |
||
| 1166 | enemies[num].imgTime = 0; |
||
| 1167 | return enemyTypes[enemies[num].type].getImg(enemies[num].imgTime); |
||
| 1168 | } |
||
| 1169 | } |
||
| 1170 | } |