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

author	nemo
	Fri, 25 Mar 2011 19:25:50 -0400
changeset 5049	96e51a62fb7f
parent 5024	1e332947147c
child 5150	63ad8a648afd
permissions	-rw-r--r--