hedgewars: hedgewars/uAIAmmoTests.pas@44533b2e4fb1 (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
11046 47a8c19ecb60 more copyright fixes sheepluva parents: 10789 diff changeset	3	* Copyright (c) 2004-2015 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
10108 c68cf030eded update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers sheepluva parents: 10097 diff changeset	16	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	23	uses uConsts, uFloat, uTypes, uAIMisc;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	24	const
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	25	amtest_Rare = $00000001; // check only several positions
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	26	amtest_NoTarget = $00000002; // each pos, but no targetting
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	27	amtest_MultipleAttacks = $00000004; // test could result in multiple attacks, set AttacksNum
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	28
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	29	var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	30
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	31	type TAttackParams = record
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	32	Time, AttacksNum: Longword;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	33	Angle, Power: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	34	ExplX, ExplY, ExplR: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	35	AttackPutX, AttackPutY: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	36	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	37
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	38	function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	39	function TestBee(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	40	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	41	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	42	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	43	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	44	function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	45	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	46	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	47	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	48	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	49	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	50	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	51	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	52	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	53	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	54	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	55	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	56	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	57	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	58	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	59
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	60	type TAmmoTestProc = function (Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	61	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	62	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	63	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	64	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	65
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	66	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	67	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	68	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	69	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	70	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	71	(proc: @TestBazooka; flags: 0), // amBazooka
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	72	(proc: @TestBee; flags: amtest_Rare), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	73	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	74	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	75	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	76	(proc: nil; flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	77	(proc: nil; flags: 0), // amMine
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	78	(proc: @TestDesertEagle; flags: amtest_MultipleAttacks), // amDEagle
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	79	(proc: @TestDynamite; flags: amtest_NoTarget), // amDynamite
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	80	(proc: @TestFirePunch; flags: amtest_NoTarget), // amFirePunch
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	81	(proc: @TestWhip; flags: amtest_NoTarget), // amWhip
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	82	(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	83	(proc: nil; flags: 0), // amParachute
7789 838d2e06c377 Check cake and air attack again if walked far from initial position (not tested) unc0rr parents: 7760 diff changeset	84	(proc: @TestAirAttack; flags: amtest_Rare), // amAirAttack
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	85	(proc: nil; flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	87	(proc: nil; flags: 0), // amGirder
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	88	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	89	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	91	(proc: @TestMortar; flags: 0), // amMortar
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	92	(proc: @TestKamikaze; flags: 0), // amKamikaze
7789 838d2e06c377 Check cake and air attack again if walked far from initial position (not tested) unc0rr parents: 7760 diff changeset	93	(proc: @TestCake; flags: amtest_Rare or amtest_NoTarget), // amCake
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	94	(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	95	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	96	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	97	(proc: nil; flags: 0), // amNapalm
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	98	(proc: @TestDrillRocket; flags: 0), // amDrill
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	99	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	100	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	101	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	102	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	103	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	104	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	105	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	106	(proc: nil; flags: 0), // amVampiric
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	107	(proc: @TestSniperRifle; 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	108	(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	109	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	110	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	111	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	112	(proc: nil; flags: 0), // amPiano
3384 7eb4707d43f0 * added some comments sheepluva parents: 3382 diff changeset	113	(proc: @TestGrenade; flags: 0), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	114	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	115	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	116	(proc: @TestGrenade; flags: 0), // amSMine
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	117	(proc: @TestHammer; flags: amtest_NoTarget), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	118	(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	119	(proc: nil; flags: 0), // amDrillStrike
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	120	(proc: nil; flags: 0), // amSnowball
4883 7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure Henek parents: 4881 diff changeset	121	(proc: nil; flags: 0), // amTardis
7007 0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	122	(proc: nil; flags: 0), // amLandGun
7730 2013733f9ca9 A bit more on the knife. Also add missing files to CMakeLists nemo parents: 7721 diff changeset	123	(proc: nil; flags: 0), // amIceGun
9768 08799c901a42 Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config. nemo parents: 9722 diff changeset	124	(proc: nil; flags: 0), // amKnife
10789 acbf69e2e5cf experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up. nemo parents: 10637 diff changeset	125	(proc: nil; flags: 0), // amRubber
12193 71c47122fbc0 Add ammotype amDuck for rubber duck Wuzzy <almikes@aol.com> parents: 11476 diff changeset	126	(proc: nil; flags: 0), // amAirMine
13851 f01798038c2e Rename amDuck and related symbols to amCreeper, gtCreeper, etc. Wuzzy <Wuzzy2@mail.ru> parents: 13671 diff changeset	127	(proc: nil; flags: 0), // amCreeper
12898 8a40ce061d94 Machinegun. also tweaked ignore alfadur parents: 12621 diff changeset	128	(proc: @TestShotgun; flags: 0) // amMinigun
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	129	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	130
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	131	implementation
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	132	uses uVariables, uUtils, uGearsHandlers;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	133
5150 63ad8a648afd Allow head of rope to attach to hogs/barrels/crates again. Rope still does not, to avoid the bug. nemo parents: 5024 diff changeset	134	function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	135	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	136	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	137	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	138
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	139	function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	140	const cExtraTime = 300;
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	141	var Vx, Vy, r, mX, mY: real;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	142	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	143	EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	144	valueResult: LongInt;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	145	targXWrap, x, y, dX, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	146	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	147	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	148	begin
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	149	mX:= hwFloat2Float(Me^.X);
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	150	mY:= hwFloat2Float(Me^.Y);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	151	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	152	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	153	ap.ExplR:= 0;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	154	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	155	if (Targ.Point.X < mX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	156	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	157	else targXWrap:= Targ.Point.X - (RightX-LeftX);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	158	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	159	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	160	rTime:= rTime + 300 + Level * 50 + random(300);
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	161	if (WorldEdge = weWrap) and (random(2)=0) then
14212 ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	162	Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) + AIrndOffset(Targ, Level) - mX) / rTime
ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	163	else Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) + AIrndOffset(Targ, Level) - mX) / rTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	164	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	165	r:= sqr(Vx) + sqr(Vy);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	166	if not (r > 1) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	167	begin
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	168	x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	169	y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	170	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	171	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	172	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	173	repeat
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	174	x:= CheckWrap(x);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	175	x:= x + dX;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	176
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	177	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	178	dX:= dX + windSpeed;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	179	//dX:= CheckBounce(x,dX);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	180	dY:= dY + cGravityf;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	181	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	182	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	183	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t < -cExtraTime);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	184
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	185	EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	186	EY:= trunc(y);
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	187	if t >= -cExtraTime then
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	188	begin
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	189	if Level = 1 then
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	190	value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	191	else
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	192	value:= RateExplosion(Me, EX, EY, 101);
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	193	end else
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	194	value:= BadTurn;
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	195
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	196	if (value = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
11476 c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	197	if GameFlags and gfSolidLand = 0 then
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	198	value := 1024 - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	199	else value := BadTurn;
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	200
14227 1d678dee55d1 fpc likes brackets nemo parents: 14226 diff changeset	201	if (valueResult < value) or ((valueResult = value) and (Level < 3)) then
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	202	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	203	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	204	ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	205	ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	206	ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	207	ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	208	valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	209	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	210	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	211	until rTime > 5050 - Level * 800;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	212	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	213	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	214
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	215	function calcBeeFlight(Me: PGear; x, y, dx, dy, tX, tY: real; var eX, eY: LongInt): LongInt;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	216	var t: Longword;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	217	f: boolean;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	218	speed, d: real;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	219	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	220	// parabola flight before activation
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	221	t:= 500;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	222	repeat
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	223	x:= x + dx;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	224	y:= y + dy;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	225	dy:= dy + cGravityf;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	226	f:= ((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	227	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	228	dec(t)
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	229	until (t = 0) or (y >= cWaterLine) or f;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	230
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	231	if f then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	232	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	233	eX:= trunc(x);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	234	eY:= trunc(y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	235	exit(RateExplosion(Me, eX, eY, 101, afTrackFall or afErasesLand));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	236	end;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	237
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	238
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	239	// activated
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	240	t:= 5000;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	241	speed:= sqrt(sqr(dx) + sqr(dy));
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	242
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	243	repeat
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	244	if (t and $F) = 0 then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	245	begin
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	246	dx:= dx + 0.000064 * (tX - x);
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	247	dy:= dy + 0.000064 * (tY - y);
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	248	d := speed / sqrt(sqr(dx) + sqr(dy));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	249	dx:= dx * d;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	250	dy:= dy * d;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	251	end;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	252
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	253	x:= x + dx;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	254	y:= y + dy;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	255	f:= ((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	256	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	257	dec(t)
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	258	until (t = 0) or f;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	259
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	260	if f then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	261	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	262	eX:= trunc(x);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	263	eY:= trunc(y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	264	exit(RateExplosion(Me, eX, eY, 101, afTrackFall or afErasesLand));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	265	end
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	266	else
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	267	calcBeeFlight:= BadTurn
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	268	end;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	269
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	270	function TestBee(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	271	var i, j: LongInt;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	272	valueResult, v, a, p: LongInt;
12621 d972b31f8881 fix some fpc hints sheepluva parents: 12193 diff changeset	273	mX, mY: real;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	274	eX, eY: LongInt;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	275	begin
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	276	if Level > 1 then
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	277	exit(BadTurn);
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	278
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	279	eX:= 0;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	280	eY:= 0;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	281	mX:= hwFloat2Float(Me^.X);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	282	mY:= hwFloat2Float(Me^.Y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	283	valueResult:= BadTurn;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	284	for i:= 0 to 8 do
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	285	for j:= 0 to 1 do
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	286	begin
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	287	a:= i * 120;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	288	p:= random(cMaxPower - 200) + 180;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	289
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	290	if j = 0 then
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	291	a:= -a;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	292
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	293	v:= calcBeeFlight(Me
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	294	, mX
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	295	, mY
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	296	, sin(a * pi / 2048) * p / cPowerDivisor
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	297	, -cos(a * pi / 2048) * p / cPowerDivisor
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	298	, Targ.Point.X
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	299	, Targ.Point.Y
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	300	, eX
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	301	, eY);
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	302
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	303	if v > valueResult then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	304	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	305	ap.ExplR:= 100;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	306	ap.ExplX:= eX;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	307	ap.ExplY:= eY;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	308	ap.Angle:= a;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	309	ap.Power:= p;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	310	valueResult:= v
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	311	end
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	312	end;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	313
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	314	ap.AttackPutX:= Targ.Point.X;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	315	ap.AttackPutY:= Targ.Point.Y;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	316
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	317	if valueResult > 0 then
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	318	TestBee:= valueResult - 5000
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	319	else
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	320	TestBee:= BadTurn // no digging
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	321	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	322
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	323	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	324	var Vx, Vy, r, mX, mY: real;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	325	rTime: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	326	EX, EY: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	327	valueResult: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	328	targXWrap, x, y, dX, dY: real;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	329	t: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	330	value: LongInt;
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	331	t2: real;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	332	timer: Longint;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	333	begin
8822 fc9877ff7f1a Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient. nemo parents: 8777 diff changeset	334	if (Level > 3) then exit(BadTurn);
fc9877ff7f1a Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient. nemo parents: 8777 diff changeset	335
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	336	mX:= hwFloat2Float(Me^.X);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	337	mY:= hwFloat2Float(Me^.Y);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	338	ap.Time:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	339	rTime:= 350;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	340	ap.ExplR:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	341	valueResult:= BadTurn;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	342	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	343	if (Targ.Point.X < mX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	344	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	345	else targXWrap:= Targ.Point.X - (RightX-LeftX);
10637 13a5dd92ebf9 init timer to 0 nemo parents: 10108 diff changeset	346	timer:= 0;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	347	repeat
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	348	rTime:= rTime + 300 + Level * 50 + random(300);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	349	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	350	Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) - mX) / rTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	351	else Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	352	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	353	r:= sqr(Vx) + sqr(Vy);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	354	if not (r > 1) then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	355	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	356	x:= mX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	357	y:= mY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	358	dX:= Vx;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	359	dY:= -Vy;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	360	t:= rTime;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	361	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	362	x:= CheckWrap(x);
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	363	x:= x + dX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	364	y:= y + dY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	365	dX:= dX + windSpeed;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	366	dY:= dY + cGravityf;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	367	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	368	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	369	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (y > cWaterLine);
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	370
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	371	if TestCollExcludingObjects(trunc(x), trunc(y), 5) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	372	begin
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	373	timer := 500;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	374	t2 := 0.5 / sqrt(sqr(dX) + sqr(dY));
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	375	dX := dX * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	376	dY := dY * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	377	repeat
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	378	x:= x + dX;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	379	y:= y + dY;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	380	dec(timer);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	381	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 22)
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	382	or (x < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	383	or (y < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	384	or (trunc(x) > LAND_WIDTH)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	385	or (trunc(y) > LAND_HEIGHT)
9136 78f087fd3e5b parsing ok, stops at uGears koda parents: 9127 diff changeset	386	or (not TestCollExcludingObjects(trunc(x), trunc(y), 5))
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	387	or (timer = 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	388	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	389	EX:= trunc(x);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	390	EY:= trunc(y);
8862 85eb1f4b4a5f drill test tweak based on watching AI play nemo parents: 8824 diff changeset	391	// Try to prevent AI from thinking firing into water will cause a drowning
10637 13a5dd92ebf9 init timer to 0 nemo parents: 10108 diff changeset	392	if (EY < cWaterLine-5) and (timer > 0) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then exit(BadTurn);
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	393	if Level = 1 then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	394	value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	395	else value:= RateExplosion(Me, EX, EY, 101);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	396	if valueResult <= value then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	397	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	398	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	399	ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	400	ap.ExplR:= 100;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	401	ap.ExplX:= EX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	402	ap.ExplY:= EY;
8824 fe9eacd390f2 Unbreak lua localisation, fix untranslated login prompt, update translations. nemo parents: 8822 diff changeset	403	valueResult:= value-2500 // trying to make it slightly less attractive than a bazooka, to prevent waste. AI could use awareness of weapon count
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	404	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	405	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	406	until rTime > 5050 - Level * 800;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	407	TestDrillRocket:= valueResult
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	408	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	409
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	410
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	411	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	412	var Vx, Vy, r: real;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	413	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	414	EX, EY: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	415	valueResult: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	416	targXWrap, x, y, dX, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	417	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	418	value: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	419
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	420	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	421	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	422	meY:= hwFloat2Float(Me^.Y);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	423	ap.Time:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	424	rTime:= 350;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	425	ap.ExplR:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	426	valueResult:= BadTurn;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	427	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	428	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	429	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	430	else targXWrap:= Targ.Point.X - (RightX-LeftX);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	431	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	432	rTime:= rTime + 300 + Level * 50 + random(1000);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	433	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	434	Vx:= - windSpeed * rTime * 0.5 + ((targXWrap + AIrndSign(2)) - meX) / rTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	435	else Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	436	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	437	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	438	if not (r > 1) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	439	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	440	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	441	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	442	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	443	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	444	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	445	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	446	x:= CheckWrap(x);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	447	x:= x + dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	448	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	449	dX:= dX + windSpeed;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	450	dY:= dY + cGravityf;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	451	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	452	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	453	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	454	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	455	EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	456
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	457	value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall);
8013 5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	458	// LOL copypasta: this is score for digging with... snowball
5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	459	//if value = 0 then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	460	// value:= - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	461
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	462	if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	463	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	464	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	465	ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	466	ap.ExplR:= 0;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	467	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	468	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	469	valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	470	end;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	471	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	472	until (rTime > 5050 - Level * 800);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	473	TestSnowball:= valueResult
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	474	end;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	475
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	476	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	477	var Vx, Vy, r: real;
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	478	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	479	TestTime: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	480	targXWrap, x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	481	t: 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	482	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	483	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	484	meY:= hwFloat2Float(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	485	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	486	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	487	ap.ExplR:= 0;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	488	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	489	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	490	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	491	else targXWrap:= Targ.Point.X - (RightX-LeftX);
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	492	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	493	inc(TestTime, 300);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	494	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	495	Vx:= (targXWrap - meX) / TestTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	496	else Vx:= (Targ.Point.X - meX) / TestTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	497	Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	498	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	499	if not (r > 1) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	500	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	501	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	502	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	503	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	504	t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	505	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	506	x:= CheckWrap(x);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	507	x:= x + Vx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	508	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	509	dY:= dY + cGravityf;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	510	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	511	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	512	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	513	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	514	EY:= trunc(y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	515	if t < 50 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	516	Score:= RateExplosion(Me, EX, EY, 97) // average of 17 attempts, most good, but some failing spectacularly
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	517	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	518	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	519
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	520	if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	521	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	522	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	523	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	524	ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	525	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	526	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	527	valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	528	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	529	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	530	until (TestTime > 5050 - Level * 800);
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	531	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	532	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	533
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	534	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	535	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	536	var Vx, Vy, r: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	537	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	538	TestTime: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	539	targXWrap, x, y, meX, meY, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	540	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	541	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	542	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	543	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	544	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	545	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	546	meY:= hwFloat2Float(Me^.Y);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	547	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	548	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	549	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	550	else targXWrap:= Targ.Point.X - (RightX-LeftX);
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	551	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	552	inc(TestTime, 1000);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	553	if (WorldEdge = weWrap) and (random(2)=0) then
14212 ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	554	Vx:= (targXWrap + AIrndOffset(Targ, Level) - meX) / (TestTime + tDelta)
ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	555	else Vx:= (Targ.Point.X + AIrndOffset(Targ, Level) - meX) / (TestTime + tDelta);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	556	Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	557	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	558	if not (r > 1) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	559	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	560	x:= meX;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	561	y:= meY;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	562	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	563	t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	564	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	565	x:= CheckWrap(x);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	566	x:= x + Vx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	567	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	568	dY:= dY + cGravityf;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	569	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	570	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	571	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	572	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	573	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	574	if t < 50 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	575	if Level = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	576	Score:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
6769 44ad49a3a126 Add drowning to grenade too, try some little optimisations nemo parents: 6767 diff changeset	577	else Score:= RateExplosion(Me, EX, EY, 101)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	578	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	579	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	580
8013 5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	581	if (valueResult < Score) and (Score > 0) then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	582	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	583	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 3));
b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	584	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 20);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	585	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	586	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	587	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	588	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	589	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	590	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	591	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	592	//until (Score > 204800) or (TestTime > 4000);
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	593	until TestTime > 4500 - Level * 512;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	594	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	595	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	596
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	597	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	598	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	599	var Vx, Vy, r: real;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	600	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	601	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	602	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	603	t: LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	604	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	605	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	606	TestTime:= 500;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	607	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	608	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	609	meY:= hwFloat2Float(Me^.Y);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	610	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	611	inc(TestTime, 900);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	612	// Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	613	if meX<Targ.Point.X then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	614	Vx:= ((Targ.Point.X+10) - meX) / (TestTime + tDelta)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	615	else
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	616	Vx:= ((Targ.Point.X-10) - meX) / (TestTime + tDelta);
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	617	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	618	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	619	if not (r > 1) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	620	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	621	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	622	y:= meY;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	623	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	624	t:= TestTime;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	625	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	626	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	627	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	628	dY:= dY + cGravityf;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	629	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	630	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	631	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	632	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	633	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	634	if t < 50 then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	635	Score:= RateExplosion(Me, EX, EY, 41)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	636	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	637	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	638
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	639	if Score > 0 then
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	640	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	641	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 2));
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	642	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	643	ap.Time:= TestTime div 1000 * 1000;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	644	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	645	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	646	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	647	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	648	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	649	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	650	until (TestTime = 4100);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	651	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	652	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	653
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	654	function TestWatermelon(Me: PGear; Targ: TTarget; 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	655	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	656	var Vx, Vy, r: real;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	657	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	658	TestTime: Longword;
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	659	targXWrap, x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	660	t: LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	661	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	662	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	663	TestTime:= 500;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	664	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	665	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	666	meY:= hwFloat2Float(Me^.Y);
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	667	if (WorldEdge = weWrap) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	668	if (Targ.Point.X < meX) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	669	targXWrap:= Targ.Point.X + (RightX-LeftX)
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	670	else targXWrap:= Targ.Point.X - (RightX-LeftX);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	671	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	672	inc(TestTime, 900);
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	673	if (WorldEdge = weWrap) and (random(2)=0) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	674	Vx:= (targXWrap - meX) / (TestTime + tDelta)
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	675	else Vx:= (Targ.Point.X - meX) / (TestTime + tDelta);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	676	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	677	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	678	if not (r > 1) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	679	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	680	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	681	y:= meY;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	682	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	683	t:= TestTime;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	684	repeat
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	685	x:= CheckWrap(x);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	686	x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	687	y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	688	dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	689	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	690	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	691	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	692
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	693	EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	694	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	695	if t < 50 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	696	Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	697	else
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	698	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	699
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	700	if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	701	begin
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	702	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	703	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	704	ap.Time:= TestTime div 1000 * 1000;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	705	ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	706	ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	707	ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	708	valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	709	end;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	710	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	711	until (TestTime = 4100);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	712	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	713	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	714
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	715
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	716	function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	717	var A, B, D, T: real;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	718	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	719	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	720	A:= sqr(cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	721	B:= - cGravityf * (TY - MY) - 1;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	722	C:= sqr(TY - MY) + sqr(TX - MX);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	723	D:= sqr(B) - A * C;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	724	if D >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	725	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	726	D:= sqrt(D) - B;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	727	if D >= 0 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	728	T:= sqrt(D * 2 / A)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	729	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	730	T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	731	Solve:= trunc(T)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	732	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	733	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	734	Solve:= 0
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	735	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	736
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	737	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	738	//const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	739	var Vx, Vy: real;
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	740	Score, EX, EY: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	741	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	742	x, y, dY, meX, meY: real;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	743	begin
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	744	TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	745	ap.ExplR:= 0;
7790 040fc517fece - Fix desyncs triggered by AI unc0rr parents: 7789 diff changeset	746
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	747	meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	748	meY:= hwFloat2Float(Me^.Y);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	749
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	750	if (Level > 2) then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	751	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	752
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	753	TestTime:= Solve(Targ.Point.X, Targ.Point.Y, trunc(meX), trunc(meY));
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	754
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	755	if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	756	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	757
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	758	Vx:= (Targ.Point.X - meX) / TestTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	759	Vy:= cGravityf * (TestTime div 2) - (Targ.Point.Y - meY) / TestTime;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	760
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	761	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	762	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	763	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	764
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	765	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	766	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	767	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	768	dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	769	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	770	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	771	until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	772	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, EX, EY, 4))) or (EY > cWaterLine);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	773
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	774	if (EY < cWaterLine) and (dY >= 0) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	775	begin
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	776	Score:= RateExplosion(Me, EX, EY, 91);
9005 15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	777	if (Score = 0) then
15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	778	if (dY > 0.15) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	779	Score:= - abs(Targ.Point.Y - EY) div 32
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	780	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	781	Score:= BadTurn
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	782	else if (Score < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	783	Score:= BadTurn
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	784	end
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	785	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	786	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	787
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	788	if Score > 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	789	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	790	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	791	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	792	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	793	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	794	ap.ExplY:= EY;
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	795	TestMortar:= Score
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	796	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	797	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	798
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	799	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	800	const
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	801	MIN_RANGE = 80;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	802	MAX_RANGE = 400;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	803	var Vx, Vy, x, y: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	804	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	805	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	806	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	807	TestShotgun:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	808	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	809	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	810	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	811	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	812	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	813	range:= Metric(trunc(x), trunc(y), Targ.Point.X, Targ.Point.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	814	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	815	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	816
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	817	Vx:= (Targ.Point.X - x) * 1 / 1024;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	818	Vy:= (Targ.Point.Y - y) * 1 / 1024;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	819	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	820	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	821	x:= x + vX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	822	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	823	rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	824	ry:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	825	if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	826	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, rx, ry, 2)) then
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	827	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	828	x:= x + vX * 8;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	829	y:= y + vY * 8;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	830	valueResult:= RateShotgun(Me, vX, vY, rx, ry);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	831
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	832	if (valueResult = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
11476 c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	833	begin
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	834	if GameFlags and gfSolidLand = 0 then
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	835	valueResult:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, rx, ry) div 64
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	836	else valueResult := BadTurn
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	837	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	838	else
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	839	dec(valueResult, Level * 4000);
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	840	// 27/20 is reuse bonus
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	841	exit(valueResult * 27 div 20)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	842	end
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	843	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	844	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	845	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	846	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	847	or (trunc(y) > LAND_HEIGHT);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	848
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	849	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	850	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	851
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	852	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8971 fcb29a13b1b1 Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing. nemo parents: 8959 diff changeset	853	var Vx, Vy, x, y, t: real;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	854	d: Longword;
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	855	ix, iy, valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	856	begin
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	857	if (Level > 4) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn);
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	858	Level:= Level; // avoid compiler hint
8952 a6ee1e7310fb trying to make AI aware of mine/explosive break point. also remove redundant test. nemo parents: 8950 diff changeset	859	ap.ExplR:= 1;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	860	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	861	ap.Power:= 1;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	862
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	863	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	864	y:= hwFloat2Float(Me^.Y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	865
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	866	if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 20 then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	867	exit(BadTurn);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	868
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	869	t:= 2 / sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y));
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	870	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	871	Vy:= (Targ.Point.Y - y) * t;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	872	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	873	d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	874
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	875	ix:= trunc(x);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	876	iy:= trunc(y);
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	877
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	878	if ((ix and LAND_WIDTH_MASK) = 0) and ((iy and LAND_HEIGHT_MASK) = 0) then
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	879	repeat
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	880	if Land[iy, ix] <> 0 then
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	881	inc(d);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	882	x:= x + vX;
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	883	y:= y + vY;
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	884	ix:= trunc(x);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	885	iy:= trunc(y);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	886	until (Abs(Targ.Point.X - ix) + Abs(Targ.Point.Y - iy) < 5)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	887	or (x < 0)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	888	or (y < 0)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	889	or (ix >= LAND_WIDTH)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	890	or (iy >= LAND_HEIGHT)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	891	or (d > 48);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	892
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	893	if Abs(Targ.Point.X - ix) + Abs(Targ.Point.Y - iy) < 5 then
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	894	begin
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	895	ap.AttacksNum:= 1 + (d + 8) div 12;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	896	valueResult:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, 7, 20, vX0.125, vY0.125, afTrackFall) - ap.AttacksNum
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	897	end
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	898	else
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	899	valueResult:= BadTurn;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	900
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	901	TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	902	end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	903
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	904
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	905	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8971 fcb29a13b1b1 Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing. nemo parents: 8959 diff changeset	906	var Vx, Vy, x, y, t, dmg: real;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	907	d: Longword;
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	908	//fallDmg: LongInt;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	909	begin
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	910	if (Level > 3) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn);
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	911	Level:= Level; // avoid compiler hint
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	912	ap.ExplR:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	913	ap.Time:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	914	ap.Power:= 1;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	915	x:= hwFloat2Float(Me^.X);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	916	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	917	if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 40 then
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	918	exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	919
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	920	dmg:= sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y));
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	921	t:= 1.5 / dmg;
7208 62e36dc45098 Ignore all objects for fall tracing with shove to avoid considering checkins as obstacles. many objects will get knocked by the kick anyway, so end result should be pretty good. Oh, and ditch the sniper rifle doubling. nemo parents: 7206 diff changeset	922	dmg:= dmg * 0.025; // div 40
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	923	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	924	Vy:= (Targ.Point.Y - y) * t;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	925	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	926	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	927
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	928	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	929	x:= x + vX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	930	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	931	if ((trunc(x) and LAND_WIDTH_MASK) = 0)and((trunc(y) and LAND_HEIGHT_MASK) = 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	932	and (Land[trunc(y), trunc(x)] <> 0) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	933	inc(d);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	934	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	935	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	936	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	937	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	938	or (trunc(y) > LAND_HEIGHT)
7873 266fe9f1e5a9 Improve TestSniperRifle a bit unc0rr parents: 7790 diff changeset	939	or (d > 22);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	940
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	941	if Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4 then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	942	TestSniperRifle:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, trunc(dmg), 20, vX0.166, vY0.166, afTrackFall)
8952 a6ee1e7310fb trying to make AI aware of mine/explosive break point. also remove redundant test. nemo parents: 8950 diff changeset	943	else TestSniperRifle:= BadTurn;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	944	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	945
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	946
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	947	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	948	var valueResult, a, v1, v2: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	949	x, y, trackFall: LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	950	dx, dy: real;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	951	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	952	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	953
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	954	if Level < 3 then trackFall:= afTrackFall
8026 4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions) koda parents: 8013 diff changeset	955	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	956
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	957	ap.ExplR:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	958	ap.Time:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	959	ap.Power:= 1;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	960	x:= hwRound(Me^.X);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	961	y:= hwRound(Me^.Y);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	962
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	963	a:= cMaxAngle div 2;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	964	valueResult:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	965
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	966	while a >= 0 do
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	967	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	968	dx:= sin(a / cMaxAngle * pi) * 0.5;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	969	dy:= cos(a / cMaxAngle * pi) * 0.5;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	970
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	971	v1:= RateShove(Me, x - 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	972	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	973	, -dx, -dy, trackFall);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	974	v2:= RateShove(Me, x + 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	975	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	976	, dx, -dy, trackFall);
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	977	if (v1 > valueResult) or (v2 > valueResult) then
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	978	if (v2 > v1)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	979	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	980	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	981	ap.Angle:= a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	982	valueResult:= v2
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	983	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	984	else
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	985	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	986	ap.Angle:= -a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	987	valueResult:= v1
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	988	end;
6770 7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	989
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	990	a:= a - 15 - random(cMaxAngle div 16)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	991	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	992
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	993	if valueResult <= 0 then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	994	valueResult:= BadTurn;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	995
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	996	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	997	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	998
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	999	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1000	var valueResult, v1, v2, i: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1001	x, y, trackFall: LongInt;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	1002	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1003	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1004
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1005	if Level = 1 then trackFall:= afTrackFall
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1006	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1007
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1008	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1009	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1010	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1011	x:= hwRound(Me^.X);
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1012	y:= hwRound(Me^.Y) + 4;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1013
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1014	v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1015	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1016	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1017	v1:= v1 + RateShove(Me, x - 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1018	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1019	, -0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1020	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1021	v1:= v1 + RateShove(Me, x - 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1022	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1023	, -0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1024
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	1025
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1026	// now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1027	v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1028	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1029	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1030	v2:= v2 + RateShove(Me, x + 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1031	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1032	, 0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1033	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1034	v2:= v2 + RateShove(Me, x + 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1035	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1036	, 0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1037
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1038	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1039	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1040	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1041	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1042	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1043	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1044	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1045	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1046	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1047	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1048	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1049
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1050	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1051	valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1052
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1053	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	1054	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	1055
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	1056
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1057	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1058	var valueResult, v1, v2: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1059	x, y, trackFall: LongInt;
6770 7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	1060	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1061	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1062
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1063	if Level = 1 then trackFall:= afTrackFall
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1064	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1065
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1066	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1067	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1068	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1069	x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1070	y:= hwRound(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1071
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1072	// check left direction
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1073	{first RateShove checks farthermost of two whip's AmmoShove attacks
13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1074	to encourage distant attacks (damaged hog is excluded from view of second
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1075	RateShove call)}
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1076	v1:= RateShove(Me, x - 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1077	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1078	, -1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1079	v1:= v1 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1080	RateShove(Me, x - 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1081	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1082	, -1, -0.8, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1083	// now try opposite direction
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1084	v2:= RateShove(Me, x + 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1085	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1086	, 1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1087	v2:= v2 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1088	RateShove(Me, x + 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1089	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1090	, 1, -0.8, trackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1091
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1092	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1093	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1094	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1095	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1096	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1097	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1098	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1099	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1100	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1101	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1102	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1103
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1104	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1105	valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1106	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1107	inc(valueResult);
6770 7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	1108
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1109	TestWhip:= valueResult;
6770 7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	1110	end;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	1111
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1112	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1113	const step = 8;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1114	var valueResult, i, v, tx: LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1115	trackFall: LongInt;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1116	t, d, x, y, dx, dy, cx: real;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1117	begin
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1118	ap.ExplR:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1119	ap.Time:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1120	ap.Power:= 1;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1121
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1122	if Level = 1 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1123	trackFall:= afTrackFall
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1124	else if Level = 2 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1125	trackFall:= 0
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1126	else
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1127	exit(BadTurn);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1128
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1129	valueResult:= 0;
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1130	v:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1131
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1132	x:= hwFloat2Float(Me^.X);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1133	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1134	d:= sqrt(sqr(Targ.Point.X - x) + sqr(Targ.Point.Y - y));
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1135	if d < 10 then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1136	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1137	dx:= 0;
14547 90893b397933 Fix dy hardcoded value in kamikaze test unc0rr parents: 14546 diff changeset	1138	dy:= step;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1139	ap.Angle:= 2048
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1140	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1141	else
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1142	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1143	t:= step / d;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1144	dx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1145	dy:= (Targ.Point.Y - y) * t;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1146
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1147	ap.Angle:= DxDy2AttackAnglef(dx, -dy)
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1148	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1149
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1150	if dx >= 0 then cx:= 0.45 else cx:= -0.45;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1151
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1152	for i:= 1 to 512 div step - 2 do
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1153	begin
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1154	x:= x + dx;
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1155	y:= y + dy;
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1156
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1157	valueResult:= valueResult +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1158	RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1159	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1160	, cx, -0.9, trackFall or afSetSkip);
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1161	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1162
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1163	if (d < 10) and (dx = 0) then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1164	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1165	x:= hwFloat2Float(Me^.X);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1166	y:= hwFloat2Float(Me^.Y);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1167	tx:= trunc(x);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1168	v:= RateShove(Me, tx, trunc(y)
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1169	, 30, 30, 25
f3a13da9fa4e oops nemo parents: 7474 diff changeset	1170	, -cx, -0.9, trackFall);
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1171	for i:= 1 to 512 div step - 2 do
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1172	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1173	y:= y + dy;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1174	v:= v +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1175	RateShove(Me, tx, trunc(y)
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1176	, 30, 30, 25
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1177	, -cx, -0.9, trackFall or afSetSkip);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1178	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1179	end;
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1180
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1181	if v > valueResult then
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1182	begin
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1183	cx:= -cx;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1184	ap.Angle:= -2048;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1185	valueResult:= v
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1186	end;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1187
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1188	v:= RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1189	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1190	, cx, -0.9, trackFall);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1191	valueResult:= valueResult + v - KillScore * friendlyfactor div 100 * 1024;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1192
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1193	if v < 65536 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1194	inc(valueResult, RateExplosion(Me, trunc(x), trunc(y), 30));
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1195
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1196	TestKamikaze:= valueResult;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1197	end;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1198
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1199	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1200	var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1201	begin
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1202	Level:= Level; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1203	Targ:= Targ;
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1204
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1205	ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1206	ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1207	ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1208	ap.Angle:= 0;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1209
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	1210	rate:= RateHammer(Me);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1211	if rate = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1212	rate:= BadTurn;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1213	TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1214	end;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1215
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1216	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	1217	const cShift = 4;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1218	var bombsSpeed, X, Y, dY: real;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1219	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1220	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1221	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1222	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1223	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1224	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1225	ap.Time:= 0;
9844 8f5b48525a03 quick sanity change for AI + zerog nemo parents: 9790 diff changeset	1226	if (Level > 3) or (cGravityf = 0) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1227	exit(BadTurn);
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	1228
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	1229	ap.Angle:= 0;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1230	ap.AttackPutX:= Targ.Point.X;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1231	ap.AttackPutY:= Targ.Point.Y;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1232
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1233	bombsSpeed:= hwFloat2Float(cBombsSpeed);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1234	X:= Targ.Point.X - 135 - cShift; // hh center - cShift
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1235	X:= X - bombsSpeed * sqrt(((Targ.Point.Y + 128) * 2) / cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1236	Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1237	dY:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1238
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1239	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1240	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1241	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1242	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1243	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1244	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1245
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1246	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1247	X:= X + bombsSpeed;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1248	Y:= Y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1249	dY:= dY + cGravityf;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1250	fexit:= true;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1251
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1252	for i:= 0 to 9 do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1253	if b[i] then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1254	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1255	fexit:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1256	if TestColl(trunc(X) + LongWord(i * 30), trunc(Y), 4) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1257	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1258	b[i]:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1259	dmg[i]:= RateExplosion(Me, trunc(X) + LongWord(i * 30), trunc(Y), 58)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1260	// 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1261	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1262	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1263	until fexit or (Y > cWaterLine);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1264
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1265	for i:= 0 to 5 do
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1266	if dmg[i] <> BadTurn then
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1267	inc(valueResult, dmg[i]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1268	t:= valueResult;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1269	ap.AttackPutX:= Targ.Point.X - 60;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1270
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1271	for i:= 0 to 3 do
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1272	if dmg[i] <> BadTurn then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1273	begin
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1274	dec(t, dmg[i]);
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1275	inc(t, dmg[i + 6]);
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1276	if t > valueResult then
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1277	begin
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1278	valueResult:= t;
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1279	ap.AttackPutX:= Targ.Point.X - 30 - cShift + i * 30
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1280	end
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1281	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1282
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1283	if valueResult <= 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1284	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1285	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1286	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1287
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1288
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1289	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1290	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1291	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1292	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1293	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1294	TestTeleport := BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1295	exit(BadTurn);
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1296	Level:= Level; // avoid compiler hint
6888 32a54322d262 Get rid of TGearsType to simplify pas2c unc0rr parents: 6879 diff changeset	1297	//FillBonuses(true, [gtCase]);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1298	if bonuses.Count = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1299	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1300	if Me^.Health <= 100 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1301	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1302	maxTop := Targ.Point.Y - cHHRadius * 2;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1303
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1304	while not TestColl(Targ.Point.X, maxTop, cHHRadius) and (maxTop > topY + cHHRadius * 2 + 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1305	dec(maxTop, cHHRadius*2);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1306	if not TestColl(Targ.Point.X, maxTop + cHHRadius, cHHRadius) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1307	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1308	ap.AttackPutX := Targ.Point.X;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1309	ap.AttackPutY := maxTop + cHHRadius;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1310	TestTeleport := Targ.Point.Y - maxTop;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1311	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1312	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1313	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1314	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1315	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1316	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	1317	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1318	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1319	inc(failNum);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1320	until not TestColl(bonuses.ar[i].X, bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius, cHHRadius)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1321	or (failNum = bonuses.Count*2);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1322
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1323	if failNum < bonuses.Count*2 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1324	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1325	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1326	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1327	TestTeleport := 0;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1328	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1329	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1330	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1331
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1332
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1333	procedure checkCakeWalk(Me, Gear: PGear; var ap: TAttackParams);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1334	var i: Longword;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1335	v: LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1336	begin
8370 0c79946e96f8 Fix tons of warnings martin_bede parents: 8161 diff changeset	1337	while (not TestColl(hwRound(Gear^.X), hwRound(Gear^.Y), 6)) and (Gear^.Y.Round < LongWord(LAND_HEIGHT)) do
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1338	Gear^.Y:= Gear^.Y + _1;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1339
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1340	for i:= 0 to 2040 do
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1341	begin
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1342	cakeStep(Gear);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1343	v:= RateExplosion(Me, hwRound(Gear^.X), hwRound(Gear^.Y), cakeDmg * 2, afTrackFall);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1344	if v > ap.Power then
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1345	begin
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1346	ap.ExplX:= hwRound(Gear^.X);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1347	ap.ExplY:= hwRound(Gear^.Y);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1348	ap.Power:= v
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1349	end
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1350	end;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1351	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1352
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1353	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1354	var valueResult, v1, v2: LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1355	cake: TGear;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1356	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1357	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1358
7501 1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1359	if (Level > 2) then
1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1360	exit(BadTurn);
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1361
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1362	ap.ExplR:= 0;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1363	ap.Time:= 0;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1364	ap.Power:= BadTurn; // use it as max score value in checkCakeWalk
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1365
7721 2b1ad418ba39 - Fix warnings and hints unc0rr parents: 7716 diff changeset	1366	//FillChar(cake, sizeof(cake), 0);
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1367	cake.Radius:= 7;
13463 f1d349a52bc7 Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate Wuzzy <Wuzzy2@mail.ru> parents: 12898 diff changeset	1368	cake.CollisionMask:= lfNotCurHogCrate;
7752 65bacd3ba69e Fix crasher in TestCake unc0rr parents: 7730 diff changeset	1369	cake.Hedgehog:= Me^.Hedgehog;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1370
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1371	// check left direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1372	cake.Angle:= 3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1373	cake.dX.isNegative:= true;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1374	cake.X:= Me^.X - _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1375	cake.Y:= Me^.Y;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1376	checkCakeWalk(Me, @cake, ap);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1377	v1:= ap.Power;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1378
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1379	// now try opposite direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1380	cake.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1381	cake.dX.isNegative:= false;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1382	cake.X:= Me^.X + _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1383	cake.Y:= Me^.Y;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1384	checkCakeWalk(Me, @cake, ap);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1385	v2:= ap.Power;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1386
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1387	ap.Power:= 1;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1388
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1389	if (v2 > v1) then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1390	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1391	ap.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1392	valueResult:= v2
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1393	end
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1394	else
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1395	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1396	ap.Angle:= -1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1397	valueResult:= v1
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1398	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1399
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1400	if valueResult <= 0 then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1401	valueResult:= BadTurn;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1402
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1403	TestCake:= valueResult;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1404	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1405
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1406	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1407	var valueResult: LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1408	x, y, dx, dy: real;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1409	EX, EY, t: LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1410	begin
9790 0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1411	Targ:= Targ; // avoid compiler hint
0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1412
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1413	x:= hwFloat2Float(Me^.X) + hwSign(Me^.dX) * 7;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1414	y:= hwFloat2Float(Me^.Y);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1415	dx:= hwSign(Me^.dX) * 0.03;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1416	dy:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1417	t:= 5000;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1418	repeat
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1419	dec(t);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1420	x:= x + dx;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1421	dy:= dy + cGravityf;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1422	y:= y + dy;
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1423
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1424	if TestColl(trunc(x), trunc(y), 3) then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1425	t:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1426	until t = 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1427
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1428	EX:= trunc(x);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1429	EY:= trunc(y);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1430
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1431	if Level = 1 then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1432	valueResult:= RateExplosion(Me, EX, EY, 76, afTrackFall or afErasesLand)
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1433	else
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1434	valueResult:= RateExplosion(Me, EX, EY, 76);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1435
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1436	if (valueResult > 0) then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1437	begin
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1438	ap.Angle:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1439	ap.Power:= 1;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1440	ap.Time:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1441	ap.ExplR:= 150;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1442	ap.ExplX:= EX;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1443	ap.ExplY:= EY
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1444	end else
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1445	valueResult:= BadTurn;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1446
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1447	TestDynamite:= valueResult
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1448	end;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1449
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	1450	end.

author	Wuzzy <Wuzzy2@mail.ru>
	Mon, 15 Jul 2019 21:13:01 +0200
changeset 15244	44533b2e4fb1
parent 14586	e54e41554529
child 15366	381c828865e7
permissions	-rw-r--r--