149 mX:= hwFloat2Float(Me^.X); |
149 mX:= hwFloat2Float(Me^.X); |
150 mY:= hwFloat2Float(Me^.Y); |
150 mY:= hwFloat2Float(Me^.Y); |
151 ap.Time:= 0; |
151 ap.Time:= 0; |
152 rTime:= 350; |
152 rTime:= 350; |
153 ap.ExplR:= 0; |
153 ap.ExplR:= 0; |
154 if (Targ.Point.X < mX) then |
154 if (WorldEdge = weWrap) then |
155 targXWrap:= Targ.Point.X + (RightX-LeftX) |
155 if (Targ.Point.X < mX) then |
156 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
156 targXWrap:= Targ.Point.X + (RightX-LeftX) |
|
157 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
157 valueResult:= BadTurn; |
158 valueResult:= BadTurn; |
158 repeat |
159 repeat |
159 rTime:= rTime + 300 + Level * 50 + random(300); |
160 rTime:= rTime + 300 + Level * 50 + random(300); |
160 if (WorldEdge = weWrap) and (random(2)=0) then |
161 if (WorldEdge = weWrap) and (random(2)=0) then |
161 Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime |
162 Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) - mX) / rTime |
162 else Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) - mX) / rTime; |
163 else Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
163 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime; |
164 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime; |
164 r:= sqr(Vx) + sqr(Vy); |
165 r:= sqr(Vx) + sqr(Vy); |
165 if not (r > 1) then |
166 if not (r > 1) then |
166 begin |
167 begin |
167 x:= mX; |
168 x:= mX; |
316 function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
317 function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
317 var Vx, Vy, r, mX, mY: real; |
318 var Vx, Vy, r, mX, mY: real; |
318 rTime: LongInt; |
319 rTime: LongInt; |
319 EX, EY: LongInt; |
320 EX, EY: LongInt; |
320 valueResult: LongInt; |
321 valueResult: LongInt; |
321 x, y, dX, dY: real; |
322 targXWrap, x, y, dX, dY: real; |
322 t: LongInt; |
323 t: LongInt; |
323 value: LongInt; |
324 value: LongInt; |
324 t2: real; |
325 t2: real; |
325 timer: Longint; |
326 timer: Longint; |
326 begin |
327 begin |
330 mY:= hwFloat2Float(Me^.Y); |
331 mY:= hwFloat2Float(Me^.Y); |
331 ap.Time:= 0; |
332 ap.Time:= 0; |
332 rTime:= 350; |
333 rTime:= 350; |
333 ap.ExplR:= 0; |
334 ap.ExplR:= 0; |
334 valueResult:= BadTurn; |
335 valueResult:= BadTurn; |
|
336 if (WorldEdge = weWrap) then |
|
337 if (Targ.Point.X < mX) then |
|
338 targXWrap:= Targ.Point.X + (RightX-LeftX) |
|
339 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
335 timer:= 0; |
340 timer:= 0; |
336 repeat |
341 repeat |
337 rTime:= rTime + 300 + Level * 50 + random(300); |
342 rTime:= rTime + 300 + Level * 50 + random(300); |
338 Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
343 Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
|
344 if (WorldEdge = weWrap) and (random(2)=0) then |
|
345 Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) - mX) / rTime |
|
346 else Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
339 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime; |
347 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime; |
340 r:= sqr(Vx) + sqr(Vy); |
348 r:= sqr(Vx) + sqr(Vy); |
341 if not (r > 1) then |
349 if not (r > 1) then |
342 begin |
350 begin |
343 x:= mX; |
351 x:= mX; |
344 y:= mY; |
352 y:= mY; |
345 dX:= Vx; |
353 dX:= Vx; |
346 dY:= -Vy; |
354 dY:= -Vy; |
347 t:= rTime; |
355 t:= rTime; |
348 repeat |
356 repeat |
|
357 x:= CheckWrap(x); |
349 x:= x + dX; |
358 x:= x + dX; |
350 y:= y + dY; |
359 y:= y + dY; |
351 dX:= dX + windSpeed; |
360 dX:= dX + windSpeed; |
352 dY:= dY + cGravityf; |
361 dY:= dY + cGravityf; |
353 dec(t) |
362 dec(t) |
397 function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
406 function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
398 var Vx, Vy, r: real; |
407 var Vx, Vy, r: real; |
399 rTime: LongInt; |
408 rTime: LongInt; |
400 EX, EY: LongInt; |
409 EX, EY: LongInt; |
401 valueResult: LongInt; |
410 valueResult: LongInt; |
402 x, y, dX, dY, meX, meY: real; |
411 targXWrap, x, y, dX, dY, meX, meY: real; |
403 t: LongInt; |
412 t: LongInt; |
404 value: LongInt; |
413 value: LongInt; |
405 |
414 |
406 begin |
415 begin |
407 meX:= hwFloat2Float(Me^.X); |
416 meX:= hwFloat2Float(Me^.X); |
408 meY:= hwFloat2Float(Me^.Y); |
417 meY:= hwFloat2Float(Me^.Y); |
409 ap.Time:= 0; |
418 ap.Time:= 0; |
410 rTime:= 350; |
419 rTime:= 350; |
411 ap.ExplR:= 0; |
420 ap.ExplR:= 0; |
412 valueResult:= BadTurn; |
421 valueResult:= BadTurn; |
|
422 if (WorldEdge = weWrap) then |
|
423 if (Targ.Point.X < meX) then |
|
424 targXWrap:= Targ.Point.X + (RightX-LeftX) |
|
425 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
413 repeat |
426 repeat |
414 rTime:= rTime + 300 + Level * 50 + random(1000); |
427 rTime:= rTime + 300 + Level * 50 + random(1000); |
415 Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime; |
428 if (WorldEdge = weWrap) and (random(2)=0) then |
|
429 Vx:= - windSpeed * rTime * 0.5 + ((targXWrap + AIrndSign(2)) - meX) / rTime |
|
430 else Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime; |
416 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime; |
431 Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime; |
417 r:= sqr(Vx) + sqr(Vy); |
432 r:= sqr(Vx) + sqr(Vy); |
418 if not (r > 1) then |
433 if not (r > 1) then |
419 begin |
434 begin |
420 x:= meX; |
435 x:= meX; |
421 y:= meY; |
436 y:= meY; |
422 dX:= Vx; |
437 dX:= Vx; |
423 dY:= -Vy; |
438 dY:= -Vy; |
424 t:= rTime; |
439 t:= rTime; |
425 repeat |
440 repeat |
|
441 x:= CheckWrap(x); |
426 x:= x + dX; |
442 x:= x + dX; |
427 y:= y + dY; |
443 y:= y + dY; |
428 dX:= dX + windSpeed; |
444 dX:= dX + windSpeed; |
429 dY:= dY + cGravityf; |
445 dY:= dY + cGravityf; |
430 dec(t) |
446 dec(t) |
454 |
470 |
455 function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
471 function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
456 var Vx, Vy, r: real; |
472 var Vx, Vy, r: real; |
457 Score, EX, EY, valueResult: LongInt; |
473 Score, EX, EY, valueResult: LongInt; |
458 TestTime: LongInt; |
474 TestTime: LongInt; |
459 x, y, dY, meX, meY: real; |
475 targXWrap, x, y, dY, meX, meY: real; |
460 t: LongInt; |
476 t: LongInt; |
461 begin |
477 begin |
462 meX:= hwFloat2Float(Me^.X); |
478 meX:= hwFloat2Float(Me^.X); |
463 meY:= hwFloat2Float(Me^.Y); |
479 meY:= hwFloat2Float(Me^.Y); |
464 valueResult:= BadTurn; |
480 valueResult:= BadTurn; |
465 TestTime:= 0; |
481 TestTime:= 0; |
466 ap.ExplR:= 0; |
482 ap.ExplR:= 0; |
|
483 if (WorldEdge = weWrap) then |
|
484 if (Targ.Point.X < meX) then |
|
485 targXWrap:= Targ.Point.X + (RightX-LeftX) |
|
486 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
467 repeat |
487 repeat |
468 inc(TestTime, 300); |
488 inc(TestTime, 300); |
469 Vx:= (Targ.Point.X - meX) / TestTime; |
489 if (WorldEdge = weWrap) and (random(2)=0) then |
|
490 Vx:= (targXWrap - meX) / TestTime |
|
491 else Vx:= (Targ.Point.X - meX) / TestTime; |
470 Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime; |
492 Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime; |
471 r:= sqr(Vx) + sqr(Vy); |
493 r:= sqr(Vx) + sqr(Vy); |
472 if not (r > 1) then |
494 if not (r > 1) then |
473 begin |
495 begin |
474 x:= meX; |
496 x:= meX; |
475 y:= meY; |
497 y:= meY; |
476 dY:= -Vy; |
498 dY:= -Vy; |
477 t:= TestTime; |
499 t:= TestTime; |
478 repeat |
500 repeat |
|
501 x:= CheckWrap(x); |
479 x:= x + Vx; |
502 x:= x + Vx; |
480 y:= y + dY; |
503 y:= y + dY; |
481 dY:= dY + cGravityf; |
504 dY:= dY + cGravityf; |
482 dec(t) |
505 dec(t) |
483 until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or |
506 until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or |
506 function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
529 function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
507 const tDelta = 24; |
530 const tDelta = 24; |
508 var Vx, Vy, r: real; |
531 var Vx, Vy, r: real; |
509 Score, EX, EY, valueResult: LongInt; |
532 Score, EX, EY, valueResult: LongInt; |
510 TestTime: LongInt; |
533 TestTime: LongInt; |
511 x, y, meX, meY, dY: real; |
534 targXWrap, x, y, meX, meY, dY: real; |
512 t: LongInt; |
535 t: LongInt; |
513 begin |
536 begin |
514 valueResult:= BadTurn; |
537 valueResult:= BadTurn; |
515 TestTime:= 0; |
538 TestTime:= 0; |
516 ap.ExplR:= 0; |
539 ap.ExplR:= 0; |
517 meX:= hwFloat2Float(Me^.X); |
540 meX:= hwFloat2Float(Me^.X); |
518 meY:= hwFloat2Float(Me^.Y); |
541 meY:= hwFloat2Float(Me^.Y); |
|
542 if (WorldEdge = weWrap) then |
|
543 if (Targ.Point.X < meX) then |
|
544 targXWrap:= Targ.Point.X + (RightX-LeftX) |
|
545 else targXWrap:= Targ.Point.X - (RightX-LeftX); |
519 repeat |
546 repeat |
520 inc(TestTime, 1000); |
547 inc(TestTime, 1000); |
521 Vx:= (Targ.Point.X - meX) / (TestTime + tDelta); |
548 if (WorldEdge = weWrap) and (random(2)=0) then |
|
549 Vx:= (targXWrap - meX) / (TestTime + tDelta) |
|
550 else Vx:= (Targ.Point.X - meX) / (TestTime + tDelta); |
522 Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta); |
551 Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta); |
523 r:= sqr(Vx) + sqr(Vy); |
552 r:= sqr(Vx) + sqr(Vy); |
524 if not (r > 1) then |
553 if not (r > 1) then |
525 begin |
554 begin |
526 x:= meX; |
555 x:= meX; |
527 y:= meY; |
556 y:= meY; |
528 dY:= -Vy; |
557 dY:= -Vy; |
529 t:= TestTime; |
558 t:= TestTime; |
530 repeat |
559 repeat |
|
560 x:= CheckWrap(x); |
531 x:= x + Vx; |
561 x:= x + Vx; |
532 y:= y + dY; |
562 y:= y + dY; |
533 dY:= dY + cGravityf; |
563 dY:= dY + cGravityf; |
534 dec(t) |
564 dec(t) |
535 until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
565 until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |