hedgewars: hedgewars/uAIAmmoTests.pas@633046fa040c (annotated)

71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	1	(*
1066 1f1b3686a2b0 Update copyright headers a bit unc0rr parents: 1024 diff changeset	2	* Hedgewars, a free turn based strategy game
3236 4ab3917d7d44 Update (c) lines to 2010 as unc0rr requested - they all had varying values so I just took the first year mentioned, then tacked on -2010 nemo parents: 3080 diff changeset	3	* Copyright (c) 2005-2010 Andrey Korotaev <unC0Rr@gmail.com>
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	4	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	5	* This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	6	* it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	7	* the Free Software Foundation; version 2 of the License
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	8	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	9	* This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	12	* GNU General Public License for more details.
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	13	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	14	* You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	15	* along with this program; if not, write to the Free Software
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	17	*)
5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	18
2630 079ef82eac75 revamped file access and debug display koda parents: 2616 diff changeset	19	{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display koda parents: 2616 diff changeset	20
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	21	unit uAIAmmoTests;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	22	interface
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	23	uses SDLh, uGears, uConsts, uFloat;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	24	const amtest_OnTurn = $00000001;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	25
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	26	type TAttackParams = record
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	27	Time: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	28	Angle, Power: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	29	ExplX, ExplY, ExplR: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	30	AttackPutX, AttackPutY: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	31	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	32
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	33	function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	34	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	35	function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	36	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	37	function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	38	function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	39	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	40	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	41	function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	42	function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	43	function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	44	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	45
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	46	type TAmmoTestProc = function (Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	47	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	48	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	49	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	50	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	51
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	52	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	53	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	54	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	55	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	56	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	57	(proc: @TestBazooka; flags: 0), // amBazooka
3080 b7fa8ad60e3b Engine: smxx parents: 3066 diff changeset	58	(proc: nil; flags: 0), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	59	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	60	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	61	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	62	(proc: nil; flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	63	(proc: nil; flags: 0), // amMine
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	64	(proc: @TestDesertEagle; flags: 0), // amDEagle
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	65	(proc: nil; flags: 0), // amDynamite
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	66	(proc: @TestFirePunch; flags: 0), // amFirePunch
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	67	(proc: @TestFirePunch; flags: 0), // amWhip
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	68	(proc: @TestBaseballBat; flags: 0), // amBaseballBat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	69	(proc: nil; flags: 0), // amParachute
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	70	(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	71	(proc: nil; flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	72	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	73	(proc: nil; flags: 0), // amGirder
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	74	(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	75	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	76	(proc: @TestMortar; flags: 0), // amMortar
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	77	(proc: nil; flags: 0), // amKamikaze
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	78	(proc: nil; flags: 0), // amCake
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	79	(proc: nil; flags: 0), // amSeduction
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	80	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	81	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	82	(proc: nil; flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	83	(proc: nil; flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	84	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	85	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	87	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	88	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	89	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	91	(proc: nil; flags: 0), // amVampiric
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	92	(proc: nil; flags: 0), // amSniperRifle
3342 b4f01613dcd7 Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here. nemo parents: 3236 diff changeset	93	(proc: nil; flags: 0), // amJetpack
3066 5c0efa437728 Enable birdy. Has egg bombing. Eggs should possibly have a dX component. No poison yet, no egg sprite. nemo parents: 3022 diff changeset	94	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	95	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	96	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	97	(proc: nil; flags: 0), // amPiano
633046fa040c Gas grenade: mbait parents: 3372 diff changeset	98	(proc: @TestGrenade; flags: 0) // amGasBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	99	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	100
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	101	const BadTurn = Low(LongInt) div 4;
369 2aed85310727 AI compiles, but doesn't work unc0rr parents: 351 diff changeset	102
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	103	implementation
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	104	uses uMisc, uAIMisc, uLand;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	105
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	106	function Metric(x1, y1, x2, y2: LongInt): LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	107	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	108	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	109	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	110
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	111	function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	112	var Vx, Vy, r: hwFloat;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	113	rTime: LongInt;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	114	Score, EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	115	valueResult: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	116
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	117	function CheckTrace: LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	118	var x, y, dX, dY: hwFloat;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	119	t: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	120	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	121	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	122	x:= Me^.X;
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	123	y:= Me^.Y;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	124	dX:= Vx;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	125	dY:= -Vy;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	126	t:= rTime;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	127	repeat
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	128	x:= x + dX;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	129	y:= y + dY;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	130	dX:= dX + cWindSpeed;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	131	dY:= dY + cGravity;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	132	dec(t)
2616 6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups. nemo parents: 2457 diff changeset	133	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t <= 0);
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	134	EX:= hwRound(x);
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	135	EY:= hwRound(y);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	136	value:= RateExplosion(Me, EX, EY, 101);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	137	if value = 0 then value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	138	CheckTrace:= value;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	139	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	140
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	141	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	142	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	143	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	144	ap.ExplR:= 0;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	145	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	146	repeat
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	147	rTime:= rTime + 300 + Level * 50 + random(300);
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	148	Vx:= - cWindSpeed * rTime * _0_5 + (int2hwFloat(Targ.X + AIrndSign(2)) - Me^.X) / int2hwFloat(rTime);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	149	Vy:= cGravity * rTime * _0_5 - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(rTime);
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	150	r:= Distance(Vx, Vy);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	151	if not (r > _1) then
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	152	begin
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	153	Score:= CheckTrace;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	154	if valueResult <= Score then
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	155	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	156	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	157	ap.Power:= hwRound(r * cMaxPower) - random((Level - 1) * 17 + 1);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	158	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	159	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	160	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	161	valueResult:= Score
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	162	end;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	163	end
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	164	until (rTime > 4250);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	165	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	166	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	167
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	168	function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	169	var Vx, Vy, r: hwFloat;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	170	Score, EX, EY, valueResult: LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	171	TestTime: Longword;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	172
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	173	function CheckTrace: LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	174	var x, y, dY: hwFloat;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	175	t: LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	176	begin
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	177	x:= Me^.X;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	178	y:= Me^.Y;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	179	dY:= -Vy;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	180	t:= TestTime;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	181	repeat
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	182	x:= x + Vx;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	183	y:= y + dY;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	184	dY:= dY + cGravity;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	185	dec(t)
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	186	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 7) or (t = 0);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	187	EX:= hwRound(x);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	188	EY:= hwRound(y);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	189	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 97) // average of 17 attempts, most good, but some failing spectacularly
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	190	else CheckTrace:= BadTurn
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	191	end;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	192	begin
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	193	valueResult:= BadTurn;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	194	TestTime:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	195	ap.ExplR:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	196	repeat
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	197	inc(TestTime, 300);
94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	198	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime);
94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	199	Vy:= cGravity * (TestTime div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	200	r:= Distance(Vx, Vy);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	201	if not (r > _1) then
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	202	begin
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	203	Score:= CheckTrace;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	204	if valueResult < Score then
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	205	begin
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	206	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	207	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	208	ap.Time:= TestTime;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	209	ap.ExplR:= 100;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	210	ap.ExplX:= EX;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	211	ap.ExplY:= EY;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	212	valueResult:= Score
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	213	end;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	214	end
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	215	until (TestTime > 4250);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	216	TestMolotov:= valueResult
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	217	end;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	218
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	219	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	220	const tDelta = 24;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	221	var Vx, Vy, r: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	222	Score, EX, EY, valueResult: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	223	TestTime: Longword;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	224
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	225	function CheckTrace: LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	226	var x, y, dY: hwFloat;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	227	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	228	begin
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	229	x:= Me^.X;
95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	230	y:= Me^.Y;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	231	dY:= -Vy;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	232	t:= TestTime;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	233	repeat
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	234	x:= x + Vx;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	235	y:= y + dY;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	236	dY:= dY + cGravity;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	237	dec(t)
2616 6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups. nemo parents: 2457 diff changeset	238	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t = 0);
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	239	EX:= hwRound(x);
95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	240	EY:= hwRound(y);
95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	241	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 101)
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	242	else CheckTrace:= BadTurn
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	243	end;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	244	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	245	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	246	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	247	ap.ExplR:= 0;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	248	repeat
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	249	inc(TestTime, 1000);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	250	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime + tDelta);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	251	Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime + tDelta);
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	252	r:= Distance(Vx, Vy);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	253	if not (r > _1) then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	254	begin
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	255	Score:= CheckTrace;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	256	if valueResult < Score then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	257	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	258	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	259	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	260	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	261	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	262	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	263	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	264	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	265	end;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	266	end
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	267	until (TestTime = 4000);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	268	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	269	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	270
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	271	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	272	const tDelta = 24;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	273	var Vx, Vy, r: hwFloat;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	274	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	275	TestTime: Longword;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	276
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	277	function CheckTrace: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	278	var x, y, dY: hwFloat;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	279	t: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	280	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	281	x:= Me^.X;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	282	y:= Me^.Y;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	283	dY:= -Vy;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	284	t:= TestTime;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	285	repeat
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	286	x:= x + Vx;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	287	y:= y + dY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	288	dY:= dY + cGravity;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	289	dec(t)
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	290	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t = 0);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	291	EX:= hwRound(x);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	292	EY:= hwRound(y);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	293	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 81)
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	294	else CheckTrace:= BadTurn
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	295	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	296	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	297	valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	298	TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	299	ap.ExplR:= 0;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	300	repeat
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	301	inc(TestTime, 1000);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	302	// Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	303	if Me^.X<int2hwFloat(Targ.X) then
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	304	Vx:= (int2hwFloat(Targ.X+10) - Me^.X) / int2hwFloat(TestTime + tDelta)
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	305	else
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	306	Vx:= (int2hwFloat(Targ.X-10) - Me^.X) / int2hwFloat(TestTime + tDelta);
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	307	Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y-25) - Me^.Y) / int2hwFloat(TestTime + tDelta);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	308	r:= Distance(Vx, Vy);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	309	if not (r > _1) then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	310	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	311	Score:= CheckTrace;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	312	if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	313	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	314	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	315	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	316	ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	317	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	318	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	319	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	320	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	321	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	322	end
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	323	until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	324	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	325	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	326
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	327	function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	328	const tDelta = 24;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	329	var Vx, Vy, r: hwFloat;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	330	Score, EX, EY, valueResult: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	331	TestTime: Longword;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	332
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	333	function CheckTrace: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	334	var x, y, dY: hwFloat;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	335	t: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	336	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	337	x:= Me^.X;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	338	y:= Me^.Y;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	339	dY:= -Vy;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	340	t:= TestTime;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	341	repeat
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	342	x:= x + Vx;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	343	y:= y + dY;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	344	dY:= dY + cGravity;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	345	dec(t)
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	346	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t = 0);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	347	EX:= hwRound(x);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	348	EY:= hwRound(y);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	349	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 381)
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	350	else CheckTrace:= BadTurn
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	351	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	352	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	353	valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	354	TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	355	ap.ExplR:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	356	repeat
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	357	inc(TestTime, 1000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	358	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime + tDelta);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	359	Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y-125) - Me^.Y) / int2hwFloat(TestTime + tDelta);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	360	r:= Distance(Vx, Vy);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	361	if not (r > _1) then
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	362	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	363	Score:= CheckTrace;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	364	if valueResult < Score then
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	365	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	366	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	367	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	368	ap.Time:= TestTime;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	369	ap.ExplR:= 300;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	370	ap.ExplX:= EX;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	371	ap.ExplY:= EY;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	372	valueResult:= Score
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	373	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	374	end
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	375	until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	376	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	377	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	378
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	379	function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	380	const tDelta = 24;
1001 502508979713 Fix warnings unc0rr parents: 998 diff changeset	381	var Vx, Vy: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	382	Score, EX, EY, valueResult: LongInt;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	383	TestTime: Longword;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	384
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	385	function CheckTrace: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	386	var x, y, dY: hwFloat;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	387	value: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	388	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	389	x:= Me^.X;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	390	y:= Me^.Y;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	391	dY:= -Vy;
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2357 diff changeset	392
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	393	repeat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	394	x:= x + Vx;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	395	y:= y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	396	dY:= dY + cGravity;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	397	EX:= hwRound(x);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	398	EY:= hwRound(y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	399	until TestCollExcludingMe(Me, EX, EY, 5) or (EY > 1000);
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2357 diff changeset	400
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	401	if (EY < 1000) and not dY.isNegative then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	402	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	403	value:= RateExplosion(Me, EX, EY, 91);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	404	if (value = 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	405	if (dY > _0_15) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	406	value:= - abs(Targ.Y - EY) div 32
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	407	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	408	value:= BadTurn
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	409	else if (value < 0) then value:= BadTurn
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	410	end
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	411	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	412	value:= BadTurn;
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	413
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	414	CheckTrace:= value;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	415	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	416
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	417	function Solve: LongWord;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	418	var A, B, D, T: hwFloat;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	419	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	420	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	421	A:= hwSqr(cGravity) * _0_25;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	422	B:= - cGravity * (Targ.Y - hwRound(Me^.Y)) - _1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	423	C:= sqr(Targ.Y - hwRound(Me^.Y)) + sqr(Targ.X - hwRound(Me^.X));
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	424	D:= hwSqr(B) - (A * C * 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	425	if D.isNegative = false then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	426	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	427	D:= ( - B + hwSqrt(D)) * _0_5 / A;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	428	if D.isNegative = false then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	429	T:= hwSqrt(D)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	430	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	431	T:= _0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	432	Solve:= hwRound(T)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	433	end else Solve:= 0
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	434	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	435
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	436	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	437	valueResult:= BadTurn;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	438	ap.ExplR:= 0;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	439
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	440	if (Level > 2) then exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	441
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	442	TestTime:= Solve;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	443
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	444	if TestTime = 0 then exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	445
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	446	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	447	Vy:= cGravity * (TestTime div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	448
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	449	Score:= CheckTrace;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	450	if valueResult < Score then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	451	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	452	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	453	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	454	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	455	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	456	ap.ExplY:= EY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	457	valueResult:= Score
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	458	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	459
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	460	TestMortar:= valueResult;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	461	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	462
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	463	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	464	const
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	465	MIN_RANGE = 80;
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	466	MAX_RANGE = 400;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	467	var Vx, Vy, x, y: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	468	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	469	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	470	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	471	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	472	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	473	ap.Power:= 1;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	474	range:= Metric(hwRound(Me^.X), hwRound(Me^.Y), Targ.X, Targ.Y);
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	475	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then exit(BadTurn);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	476	Vx:= (int2hwFloat(Targ.X) - Me^.X) * _1div1024;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	477	Vy:= (int2hwFloat(Targ.Y) - Me^.Y) * _1div1024;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	478	x:= Me^.X;
18012da67681 AI works properly unc0rr parents: 374 diff changeset	479	y:= Me^.Y;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	480	ap.Angle:= DxDy2AttackAngle(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	481	repeat
82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	482	x:= x + vX;
82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	483	y:= y + vY;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	484	rx:= hwRound(x);
18012da67681 AI works properly unc0rr parents: 374 diff changeset	485	ry:= hwRound(y);
2616 6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups. nemo parents: 2457 diff changeset	486	if TestCollExcludingMe(Me, rx, ry, 2) then
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	487	begin
509 fd58135a4407 Bots know shotgun behavior better unc0rr parents: 498 diff changeset	488	x:= x + vX * 8;
fd58135a4407 Bots know shotgun behavior better unc0rr parents: 498 diff changeset	489	y:= y + vY * 8;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	490	valueResult:= RateShotgun(Me, rx, ry) * 2;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	491	if valueResult = 0 then valueResult:= - Metric(Targ.X, Targ.Y, rx, ry) div 64
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	492	else dec(valueResult, Level * 4000);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	493	exit(valueResult)
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	494	end
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	495	until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4) or (x.isNegative) or (y.isNegative) or (x.Round > LAND_WIDTH) or (y.Round > LAND_HEIGHT);
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	496	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	497	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	498
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	499	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	500	var Vx, Vy, x, y, t: hwFloat;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	501	d: Longword;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	502	valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	503	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	504	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	505	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	506	ap.Power:= 1;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	507	if Abs(hwRound(Me^.X) - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) < 80 then
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	508	exit(BadTurn);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	509	t:= _0_5 / Distance(int2hwFloat(Targ.X) - Me^.X, int2hwFloat(Targ.Y) - Me^.Y);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	510	Vx:= (int2hwFloat(Targ.X) - Me^.X) * t;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	511	Vy:= (int2hwFloat(Targ.Y) - Me^.Y) * t;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	512	x:= Me^.X;
04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	513	y:= Me^.Y;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	514	ap.Angle:= DxDy2AttackAngle(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	515	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	516
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	517	repeat
d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	518	x:= x + vX;
d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	519	y:= y + vY;
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1689 diff changeset	520	if ((hwRound(x) and LAND_WIDTH_MASK) = 0)and((hwRound(y) and LAND_HEIGHT_MASK) = 0)
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	521	and (Land[hwRound(y), hwRound(x)] <> 0) then inc(d);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	522	until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4) or (x.isNegative) or (y.isNegative) or (x.Round > LAND_WIDTH) or (y.Round > LAND_HEIGHT) or (d > 200);
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	523
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	524	if Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 3 then valueResult:= max(0, (4 - d div 50) * 7 * 1024)
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	525	else valueResult:= BadTurn;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	526	TestDesertEagle:= valueResult
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	527	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	528
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	529	function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	530	var valueResult: LongInt;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	531	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	532	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	533	if (Level > 2) or (Abs(hwRound(Me^.X) - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) > 25) then
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	534	exit(BadTurn);
9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	535
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	536	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	537	ap.Power:= 1;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	538	if (Targ.X) - hwRound(Me^.X) >= 0 then ap.Angle:= cMaxAngle div 4
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	539	else ap.Angle:= - cMaxAngle div 4;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	540	valueResult:= RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X) - Me^.X), hwRound(Me^.Y), 15, 30);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	541	if valueResult <= 0 then valueResult:= BadTurn else inc(valueResult);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	542	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	543	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	544
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	545	function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	546	var i, valueResult: LongInt;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	547	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	548	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	549	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	550	ap.Power:= 1;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	551	ap.Angle:= 0;
1292 a63a13eda583 Bot could use firepunch if it doesn't find anything else useful, and it has land above his head unc0rr parents: 1263 diff changeset	552	if (Abs(hwRound(Me^.X) - Targ.X) > 25)
a63a13eda583 Bot could use firepunch if it doesn't find anything else useful, and it has land above his head unc0rr parents: 1263 diff changeset	553	or (Abs(hwRound(Me^.Y) - 50 - Targ.Y) > 50) then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	554	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	555	if TestColl(hwRound(Me^.Y), hwRound(Me^.Y) - 16, 6)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	556	and (RateShove(Me, hwRound(Me^.X) + 10 * hwSign(Me^.dX), hwRound(Me^.Y) - 40, 30, 30) = 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	557	valueResult:= Succ(BadTurn)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	558	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	559	valueResult:= BadTurn;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	560	exit(valueResult)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	561	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	562
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	563	valueResult:= 0;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	564	for i:= 0 to 4 do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	565	valueResult:= valueResult + RateShove(Me, hwRound(Me^.X) + 10 * hwSign(int2hwFloat(Targ.X) - Me^.X),
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	566	hwRound(Me^.Y) - 20 * i - 5, 10, 30);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	567	if valueResult <= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	568	valueResult:= BadTurn
1292 a63a13eda583 Bot could use firepunch if it doesn't find anything else useful, and it has land above his head unc0rr parents: 1263 diff changeset	569	else
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	570	inc(valueResult);
1292 a63a13eda583 Bot could use firepunch if it doesn't find anything else useful, and it has land above his head unc0rr parents: 1263 diff changeset	571
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	572	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	573	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	574
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	575	function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	576	const cShift = 4;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	577	var X, Y, dY: hwFloat;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	578	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	579	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	580	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	581	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	582	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	583	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	584	ap.Time:= 0;
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	585	if (Level > 3) then exit(BadTurn);
4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	586
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	587	ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	588	ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	589
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	590	X:= int2hwFloat(Targ.X - 135 - cShift); // hh center - cShift
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	591	X:= X - cBombsSpeed * hwSqrt(int2hwFloat((Targ.Y + 128) * 2) / cGravity);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	592	Y:= -_128;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	593	dY:= _0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	594
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	595	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	596	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	597	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	598	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	599	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	600	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	601
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	602	repeat
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	603	X:= X + cBombsSpeed;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	604	Y:= Y + dY;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	605	dY:= dY + cGravity;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	606	fexit:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	607
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	608	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	609	if b[i] then
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	610	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	611	fexit:= false;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	612	if TestColl(hwRound(X) + i * 30, hwRound(Y), 4) then
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	613	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	614	b[i]:= false;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	615	dmg[i]:= RateExplosion(Me, hwRound(X) + i * 30, hwRound(Y), 58)
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	616	// 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets)
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	617	end
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	618	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	619	until fexit or (Y > _1024);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	620
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	621	for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	622	t:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	623	ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	624
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	625	for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	626	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	627	dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	628	inc(t, dmg[i + 6]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	629	if t > valueResult then
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	630	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	631	valueResult:= t;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	632	ap.AttackPutX:= Targ.X - 30 - cShift + i * 30
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	633	end
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	634	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	635
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	636	if valueResult <= 0 then valueResult:= BadTurn;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	637	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	638	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	639
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	640
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	641	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	642	var
3371 da73f471798f Teleport AI: mbait parents: 3370 diff changeset	643	i, failNum: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	644	begin
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	645	FillBonuses(true, [gtCase]);
3372 5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	646	if bonuses.Count = 0 then begin
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	647	if Me^.Health <= 100 then begin
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	648	ap.AttackPutX := Targ.X;
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	649	ap.AttackPutY := topY + cHHRadius*2;
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	650	TestTeleport := Targ.Y - topY;
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	651	end
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	652	else
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	653	TestTeleport := BadTurn;
5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	654	end
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	655	else begin
3371 da73f471798f Teleport AI: mbait parents: 3370 diff changeset	656	failNum := 0;
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	657	repeat
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	658	i := random(bonuses.Count);
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	659	inc(failNum);
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	660	until(not TestColl(bonuses.ar[i].X, bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius, cHHRadius) or (failNum = bonuses.Count*2));
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	661	if failNum < bonuses.Count*2 then begin
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	662	ap.AttackPutX := bonuses.ar[i].X;
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	663	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	664	TestTeleport := 0;
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	665	end
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	666	else
da73f471798f Teleport AI: mbait parents: 3370 diff changeset	667	TestTeleport := BadTurn;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	668	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	669	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	670
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	671	end.

author	mbait
	Fri, 30 Apr 2010 12:19:25 +0000
changeset 3382	633046fa040c
parent 3372	5d3daec0d0b5
child 3384	7eb4707d43f0
permissions	-rw-r--r--