hedgewars-draft: hedgewars/uAIAmmoTests.pas@e5cb885492df (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
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	74	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	75	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	76	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	77	(proc: @TestMortar; flags: 0), // amMortar
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	78	(proc: nil; flags: 0), // amKamikaze
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	79	(proc: nil; flags: 0), // amCake
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	80	(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	81	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	82	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	83	(proc: nil; flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	84	(proc: nil; flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	85	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	87	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	88	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	89	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	91	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	92	(proc: nil; flags: 0), // amVampiric
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	93	(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	94	(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	95	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	96	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	97	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	98	(proc: nil; flags: 0), // amPiano
3384 7eb4707d43f0 * added some comments sheepluva parents: 3382 diff changeset	99	(proc: @TestGrenade; flags: 0), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	100	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	101	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	102	(proc: @TestGrenade; flags: 0), // amSMine
3963 6090d2a2472e New Weapon: Resurrector (TODO: ammo icon + sprites) Tobias Neumann <mail@tobias-neumann.eu> parents: 3928 diff changeset	103	(proc: @TestFirePunch; flags: 0), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	104	(proc: nil; flags: 0), // amResurrector
e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	105	(proc: nil; flags: 0) // amDrillStrike
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	106	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	107
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	108	const BadTurn = Low(LongInt) div 4;
369 2aed85310727 AI compiles, but doesn't work unc0rr parents: 351 diff changeset	109
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	110	implementation
3928 2560731c860d move all mobile-related functions in their own module, provides a structure for future mobile ports koda parents: 3847 diff changeset	111	uses uMisc, uAIMisc, uLand;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	112
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	113	function Metric(x1, y1, x2, y2: LongInt): LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	114	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	115	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	116	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	117
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	118	function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	119	var Vx, Vy, r: hwFloat;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	120	rTime: LongInt;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	121	Score, EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	122	valueResult: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	123
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	124	function CheckTrace: LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	125	var x, y, dX, dY: hwFloat;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	126	t: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	127	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	128	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	129	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	130	y:= Me^.Y;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	131	dX:= Vx;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	132	dY:= -Vy;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	133	t:= rTime;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	134	repeat
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	135	x:= x + dX;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	136	y:= y + dY;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	137	dX:= dX + cWindSpeed;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	138	dY:= dY + cGravity;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	139	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	140	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	141	EX:= hwRound(x);
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	142	EY:= hwRound(y);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	143	value:= RateExplosion(Me, EX, EY, 101);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	144	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	145	CheckTrace:= value;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	146	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	147
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	148	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	149	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	150	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	151	ap.ExplR:= 0;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	152	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	153	repeat
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	154	rTime:= rTime + 300 + Level * 50 + random(300);
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	155	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	156	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	157	r:= Distance(Vx, Vy);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	158	if not (r > _1) then
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	159	begin
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	160	Score:= CheckTrace;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	161	if valueResult <= Score then
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	162	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	163	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	164	ap.Power:= hwRound(r * cMaxPower) - random((Level - 1) * 17 + 1);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	165	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	166	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	167	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	168	valueResult:= Score
64 9df467527ae5 - Start AI rewrite unc0rr parents: 53 diff changeset	169	end;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	170	end
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	171	until (rTime > 4250);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	172	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	173	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	174
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	175	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	176	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	177	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	178	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	179
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	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	181	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	182	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	183	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	184	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	185	y:= Me^.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	186	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	187	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	188	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	189	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	190	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	191	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	192	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	193	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	194	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	195	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	196	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	197	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	198	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	199	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	200	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	201	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	202	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	203	repeat
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	204	inc(TestTime, 300);
94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	205	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime);
94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	206	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	207	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	208	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	209	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	210	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	211	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	212	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	213	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	214	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	215	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	216	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	217	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	218	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	219	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	220	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	221	end
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	222	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	223	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	224	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	225
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	226	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	227	const tDelta = 24;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	228	var Vx, Vy, r: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	229	Score, EX, EY, valueResult: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	230	TestTime: Longword;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	231
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	232	function CheckTrace: LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	233	var x, y, dY: hwFloat;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 370 diff changeset	234	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	235	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	236	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	237	y:= Me^.Y;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	238	dY:= -Vy;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	239	t:= TestTime;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	240	repeat
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	241	x:= x + Vx;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	242	y:= y + dY;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	243	dY:= dY + cGravity;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	244	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	245	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t = 0);
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	246	EX:= hwRound(x);
95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	247	EY:= hwRound(y);
95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	248	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 101)
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	249	else CheckTrace:= BadTurn
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	250	end;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	251	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	252	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	253	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	254	ap.ExplR:= 0;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	255	repeat
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	256	inc(TestTime, 1000);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	257	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime + tDelta);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	258	Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime + tDelta);
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	259	r:= Distance(Vx, Vy);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	260	if not (r > _1) then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	261	begin
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	262	Score:= CheckTrace;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	263	if valueResult < Score then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	264	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	265	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	266	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	267	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	268	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	269	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	270	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	271	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	272	end;
9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	273	end
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	274	until (TestTime = 4000);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	275	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	276	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	277
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	278	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	279	const tDelta = 24;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	280	var Vx, Vy, r: hwFloat;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	281	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	282	TestTime: Longword;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	283
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	284	function CheckTrace: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	285	var x, y, dY: hwFloat;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	286	t: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	287	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	288	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	289	y:= Me^.Y;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	290	dY:= -Vy;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	291	t:= TestTime;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	292	repeat
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	293	x:= x + Vx;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	294	y:= y + dY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	295	dY:= dY + cGravity;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	296	dec(t)
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	297	until TestCollExcludingMe(Me, hwRound(x), hwRound(y), 5) or (t = 0);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	298	EX:= hwRound(x);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	299	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	300	if t < 50 then CheckTrace:= RateExplosion(Me, EX, EY, 81)
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	301	else CheckTrace:= BadTurn
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	302	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	303	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	304	valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	305	TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	306	ap.ExplR:= 0;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	307	repeat
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	308	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	309	// 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	310	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	311	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	312	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	313	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	314	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	315	r:= Distance(Vx, Vy);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	316	if not (r > _1) then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	317	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	318	Score:= CheckTrace;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	319	if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	320	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	321	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	322	ap.Power:= hwRound(r * cMaxPower) + AIrndSign(random(Level) * 15);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	323	ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	324	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	325	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	326	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	327	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	328	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	329	end
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	330	until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	331	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	332	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	333
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	334	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	335	const tDelta = 24;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	336	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	337	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	338	TestTime: Longword;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	339
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	340	function CheckTrace: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	341	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	342	t: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	343	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	344	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	345	y:= Me^.Y;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	346	dY:= -Vy;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	347	t:= TestTime;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	348	repeat
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	349	x:= x + Vx;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	350	y:= y + dY;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	351	dY:= dY + cGravity;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	352	dec(t)
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	353	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	354	EX:= hwRound(x);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	355	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	356	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	357	else CheckTrace:= BadTurn
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	358	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	359	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	360	valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	361	TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	362	ap.ExplR:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	363	repeat
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	364	inc(TestTime, 1000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	365	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime + tDelta);
4226 b39ca9d087a2 compensate a bit for the reduction in power by increasing target height, avoids bouncing off terrain. nemo parents: 4157 diff changeset	366	Vy:= cGravity * ((TestTime + tDelta) div 2) - (int2hwFloat(Targ.Y-200) - 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	367	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	368	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	369	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	370	Score:= CheckTrace;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	371	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	372	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	373	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
3847 771562124b16 Engine: smaxx parents: 3820 diff changeset	374	ap.Power:= hwRound(r * cMaxPower * _0_9) + 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	375	ap.Time:= TestTime;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	376	ap.ExplR:= 300;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	377	ap.ExplX:= EX;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	378	ap.ExplY:= EY;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	379	valueResult:= Score
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	380	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	381	end
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	382	until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	383	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	384	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	385
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	386	function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	387	//const tDelta = 24;
1001 502508979713 Fix warnings unc0rr parents: 998 diff changeset	388	var Vx, Vy: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	389	Score, EX, EY, valueResult: LongInt;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	390	TestTime: Longword;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	391
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	392	function CheckTrace: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	393	var x, y, dY: hwFloat;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	394	value: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	395	begin
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	396	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	397	y:= Me^.Y;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	398	dY:= -Vy;
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2357 diff changeset	399
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	400	repeat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	401	x:= x + Vx;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	402	y:= y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	403	dY:= dY + cGravity;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	404	EX:= hwRound(x);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	405	EY:= hwRound(y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	406	until TestCollExcludingMe(Me, EX, EY, 5) or (EY > 1000);
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2357 diff changeset	407
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	408	if (EY < 1000) and not dY.isNegative then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	409	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	410	value:= RateExplosion(Me, EX, EY, 91);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	411	if (value = 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	412	if (dY > _0_15) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	413	value:= - abs(Targ.Y - EY) div 32
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	414	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	415	value:= BadTurn
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	416	else if (value < 0) then value:= BadTurn
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	417	end
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	418	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	419	value:= BadTurn;
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	420
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	421	CheckTrace:= value;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	422	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	423
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	424	function Solve: LongWord;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	425	var A, B, D, T: hwFloat;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	426	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	427	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	428	A:= hwSqr(cGravity) * _0_25;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	429	B:= - cGravity * (Targ.Y - hwRound(Me^.Y)) - _1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	430	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	431	D:= hwSqr(B) - (A * C * 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	432	if D.isNegative = false then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	433	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	434	D:= ( - B + hwSqrt(D)) * _0_5 / A;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	435	if D.isNegative = false then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	436	T:= hwSqrt(D)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	437	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	438	T:= _0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	439	Solve:= hwRound(T)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	440	end else Solve:= 0
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	441	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	442
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	443	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	444	valueResult:= BadTurn;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	445	ap.ExplR:= 0;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	446
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	447	if (Level > 2) then exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	448
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	449	TestTime:= Solve;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	450
998 65792c4e6f01 Fix AI mortar bugs unc0rr parents: 994 diff changeset	451	if TestTime = 0 then exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	452
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	453	Vx:= (int2hwFloat(Targ.X) - Me^.X) / int2hwFloat(TestTime);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	454	Vy:= cGravity * (TestTime div 2) - (int2hwFloat(Targ.Y) - Me^.Y) / int2hwFloat(TestTime);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	455
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	456	Score:= CheckTrace;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	457	if valueResult < Score then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	458	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	459	ap.Angle:= DxDy2AttackAngle(Vx, Vy) + AIrndSign(random(Level));
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	460	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	461	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	462	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	463	ap.ExplY:= EY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	464	valueResult:= Score
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	465	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	466
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	467	TestMortar:= valueResult;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	468	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	469
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	470	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	471	const
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	472	MIN_RANGE = 80;
b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	473	MAX_RANGE = 400;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	474	var Vx, Vy, x, y: hwFloat;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	475	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	476	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	477	begin
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	478	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	479	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	480	ap.Power:= 1;
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	481	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	482	y:= Me^.Y;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	483	range:= Metric(hwRound(x), hwRound(y), Targ.X, Targ.Y);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	484	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then exit(BadTurn);
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	485	Vx:= (int2hwFloat(Targ.X) - x) * _1div1024;
7d917b587547 Engine: smaxx parents: 3476 diff changeset	486	Vy:= (int2hwFloat(Targ.Y) - y) * _1div1024;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	487	ap.Angle:= DxDy2AttackAngle(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	488	repeat
82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	489	x:= x + vX;
82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	490	y:= y + vY;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	491	rx:= hwRound(x);
18012da67681 AI works properly unc0rr parents: 374 diff changeset	492	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	493	if TestCollExcludingMe(Me, rx, ry, 2) then
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	494	begin
509 fd58135a4407 Bots know shotgun behavior better unc0rr parents: 498 diff changeset	495	x:= x + vX * 8;
fd58135a4407 Bots know shotgun behavior better unc0rr parents: 498 diff changeset	496	y:= y + vY * 8;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	497	valueResult:= RateShotgun(Me, rx, ry) * 2;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	498	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	499	else dec(valueResult, Level * 4000);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	500	exit(valueResult)
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	501	end
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	502	until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	503	or (x.isNegative)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	504	or (y.isNegative)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	505	or (x.Round > LongWord(LAND_WIDTH))
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	506	or (y.Round > LongWord(LAND_HEIGHT));
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	507
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	508	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	509	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	510
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	511	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 302 diff changeset	512	var Vx, Vy, x, y, t: hwFloat;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	513	d: Longword;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	514	valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	515	begin
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	516	Level:= Level; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	517	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	518	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	519	ap.Power:= 1;
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	520	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	521	y:= Me^.Y;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	522	if Abs(hwRound(Me^.X) - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) < 80 then
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	523	exit(BadTurn);
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	524	t:= _0_5 / Distance(int2hwFloat(Targ.X) - x, int2hwFloat(Targ.Y) - y);
7d917b587547 Engine: smaxx parents: 3476 diff changeset	525	Vx:= (int2hwFloat(Targ.X) - x) * t;
7d917b587547 Engine: smaxx parents: 3476 diff changeset	526	Vy:= (int2hwFloat(Targ.Y) - y) * t;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	527	ap.Angle:= DxDy2AttackAngle(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	528	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	529
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	530	repeat
d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	531	x:= x + vX;
d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	532	y:= y + vY;
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1689 diff changeset	533	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	534	and (Land[hwRound(y), hwRound(x)] <> 0) then inc(d);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	535	until (Abs(Targ.X - hwRound(x)) + Abs(Targ.Y - hwRound(y)) < 4)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	536	or (x.isNegative)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	537	or (y.isNegative)
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	538	or (x.Round > LongWord(LAND_WIDTH))
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	539	or (y.Round > LongWord(LAND_HEIGHT))
f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	540	or (d > 200);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	541
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	542	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	543	else valueResult:= BadTurn;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	544	TestDesertEagle:= valueResult
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	545	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	546
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	547	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	548	var valueResult: LongInt;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	549	x, y: hwFloat;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	550	begin
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	551	Level:= Level; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	552	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	553	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	554	exit(BadTurn);
9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	555
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	556	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	557	ap.Power:= 1;
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	558	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	559	y:= Me^.Y;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	560	if (Targ.X) - hwRound(x) >= 0 then ap.Angle:= cMaxAngle div 4
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	561	else ap.Angle:= - cMaxAngle div 4;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	562	valueResult:= RateShove(Me, hwRound(x) + 10 * hwSign(int2hwFloat(Targ.X) - x), hwRound(y), 15, 30);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	563	if valueResult <= 0 then valueResult:= BadTurn else inc(valueResult);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	564	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	565	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	566
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	567	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	568	var i, valueResult: LongInt;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	569	x, y: hwFloat;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	570	begin
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	571	Level:= Level; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	572	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	573	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	574	ap.Power:= 1;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	575	ap.Angle:= 0;
3820 bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	576	x:= Me^.X;
bc3efe1c71ab Engine: smaxx parents: 3739 diff changeset	577	y:= Me^.Y;
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	578	if (Abs(hwRound(x) - Targ.X) > 25)
7d917b587547 Engine: smaxx parents: 3476 diff changeset	579	or (Abs(hwRound(y) - 50 - Targ.Y) > 50) then
7d917b587547 Engine: smaxx parents: 3476 diff changeset	580	begin
7d917b587547 Engine: smaxx parents: 3476 diff changeset	581	if TestColl(hwRound(x), hwRound(y) - 16, 6)
7d917b587547 Engine: smaxx parents: 3476 diff changeset	582	and (RateShove(Me, hwRound(x) + 10 * hwSign(Me^.dX), hwRound(y) - 40, 30, 30) = 0) then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	583	valueResult:= Succ(BadTurn)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	584	else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	585	valueResult:= BadTurn;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	586	exit(valueResult)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	587	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	588
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	589	valueResult:= 0;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	590	for i:= 0 to 4 do
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	591	valueResult:= valueResult + RateShove(Me, hwRound(x) + 10 * hwSign(int2hwFloat(Targ.X) - x),
7d917b587547 Engine: smaxx parents: 3476 diff changeset	592	hwRound(y) - 20 * i - 5, 10, 30);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	593	if valueResult <= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	594	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	595	else
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	596	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	597
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	598	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	599	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	600
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	601	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	602	const cShift = 4;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	603	var X, Y, dY: hwFloat;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	604	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	605	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	606	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	607	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	608	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	609	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	610	ap.Time:= 0;
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	611	if (Level > 3) then exit(BadTurn);
4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	612
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	613	ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	614	ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	615
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	616	X:= int2hwFloat(Targ.X - 135 - cShift); // hh center - cShift
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	617	X:= X - cBombsSpeed * hwSqrt(int2hwFloat((Targ.Y + 128) * 2) / cGravity);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	618	Y:= -_128;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	619	dY:= _0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	620
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	621	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	622	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	623	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	624	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	625	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	626	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	627
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	628	repeat
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	629	X:= X + cBombsSpeed;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	630	Y:= Y + dY;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	631	dY:= dY + cGravity;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	632	fexit:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	633
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	634	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	635	if b[i] then
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	636	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	637	fexit:= false;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	638	if TestColl(hwRound(X) + i * 30, hwRound(Y), 4) then
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	639	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	640	b[i]:= false;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	641	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	642	// 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	643	end
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	644	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	645	until fexit or (Y > _1024);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	646
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	647	for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	648	t:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	649	ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	650
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	651	for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	652	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	653	dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	654	inc(t, dmg[i + 6]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	655	if t > valueResult then
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	656	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	657	valueResult:= t;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	658	ap.AttackPutX:= Targ.X - 30 - cShift + i * 30
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	659	end
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	660	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	661
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	662	if valueResult <= 0 then valueResult:= BadTurn;
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	663	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	664	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	665
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	666
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	667	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	668	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	669	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	670	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	671	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	672	TestTeleport := BadTurn;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	673	Level:= Level; // avoid compiler hint
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	674	FillBonuses(true, [gtCase]);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	675	if bonuses.Count = 0 then begin
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	676	if Me^.Health <= 100 then begin
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	677	maxTop := Targ.Y - cHHRadius * 2;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	678	while not TestColl(Targ.X, maxTop, cHHRadius) and (maxTop > topY + cHHRadius * 2 + 1) do
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	679	dec(maxTop, cHHRadius*2);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	680	if not TestColl(Targ.X, maxTop + cHHRadius, cHHRadius) then begin
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	681	ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	682	ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	683	TestTeleport := Targ.Y - maxTop;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	684	end;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	685	end;
3372 5d3daec0d0b5 Teleport AI: mbait parents: 3371 diff changeset	686	end
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	687	else begin
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	688	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	689	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	690	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	691	inc(failNum);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	692	until not TestColl(bonuses.ar[i].X, bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius, cHHRadius) or (failNum = bonuses.Count*2);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	693	if failNum < bonuses.Count*2 then begin
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	694	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	695	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	696	TestTeleport := 0;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	697	end;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	698	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	699	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	700
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	701	end.

author	koda
	Fri, 12 Nov 2010 14:54:53 +0100
changeset 4246	e5cb885492df
parent 4226	b39ca9d087a2
child 4317	ba5d5a2f4c4b
permissions	-rw-r--r--