hedgewars: hedgewars/uAIAmmoTests.pas@be8fe5e0789e (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
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	28	amtest_NoTrackFall = $00000008; // skip fall tracing.
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	29
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	30	var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	31
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	32	type TAttackParams = record
15602 583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	33	Time, Bounce, 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	34	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	35	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	36	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	37	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	38
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	39	function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	40	function TestBee(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	41	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	42	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	43	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	44	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	45	function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	46	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15611 be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	47	function TestRCPlane(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	48	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	49	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	50	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	51	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	52	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	53	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	54	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	55	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	56	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15603 ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	57	function TestDrillStrike(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15604 22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	58	function TestMineStrike(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	59	function TestPiano(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	60	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	61	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	62	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	63	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
15600 7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	64	function TestMine(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	65
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	66	type TAmmoTestProc = function (Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	67	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	68	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	69	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	70	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	71
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	72	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	73	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	74	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	75	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	76	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	77	(proc: @TestBazooka; flags: 0), // amBazooka
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	78	(proc: @TestBee; flags: amtest_Rare), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	79	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	80	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	81	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	82	(proc: nil; flags: 0), // amRope
15600 7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	83	(proc: @TestMine; flags: amtest_NoTarget), // amMine
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	84	(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	85	(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	86	(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	87	(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	88	(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	89	(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	90	(proc: @TestAirAttack; flags: amtest_Rare), // amAirAttack
15604 22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	91	(proc: @TestMineStrike; flags: amtest_Rare), // amMineStrike
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	92	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	93	(proc: nil; flags: 0), // amGirder
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	94	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	95	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	96	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	97	(proc: @TestMortar; flags: 0), // amMortar
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	98	(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	99	(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	100	(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	101	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	102	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	103	(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	104	(proc: @TestDrillRocket; flags: 0), // amDrill
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	105	(proc: nil; flags: 0), // amBallgun
15611 be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	106	(proc: @TestRCPlane; flags: 0), // amRCPlane
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	107	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	108	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	109	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	110	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	111	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	112	(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	113	(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	114	(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	115	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	116	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	117	(proc: nil; flags: 0), // amPortalGun
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	118	(proc: @TestPiano; flags: amtest_Rare), // amPiano
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	119	(proc: @TestGrenade; flags: amtest_NoTrackFall), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	120	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	121	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	122	(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	123	(proc: @TestHammer; flags: amtest_NoTarget), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	124	(proc: nil; flags: 0), // amResurrector
15603 ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	125	(proc: @TestDrillStrike; flags: amtest_Rare), // amDrillStrike
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	126	(proc: nil; flags: 0), // amSnowball
4883 7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure Henek parents: 4881 diff changeset	127	(proc: nil; flags: 0), // amTardis
7007 0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	128	(proc: nil; flags: 0), // amLandGun
7730 2013733f9ca9 A bit more on the knife. Also add missing files to CMakeLists nemo parents: 7721 diff changeset	129	(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	130	(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	131	(proc: nil; flags: 0), // amRubber
12193 71c47122fbc0 Add ammotype amDuck for rubber duck Wuzzy <almikes@aol.com> parents: 11476 diff changeset	132	(proc: nil; flags: 0), // amAirMine
13851 f01798038c2e Rename amDuck and related symbols to amCreeper, gtCreeper, etc. Wuzzy <Wuzzy2@mail.ru> parents: 13671 diff changeset	133	(proc: nil; flags: 0), // amCreeper
12898 8a40ce061d94 Machinegun. also tweaked ignore alfadur parents: 12621 diff changeset	134	(proc: @TestShotgun; flags: 0) // amMinigun
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	135	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	136
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	137	implementation
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	138	uses uVariables, uUtils, uGearsHandlers;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	139
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	140	function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	141	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	142	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	143	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	144
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	145	function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	146	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	147	var Vx, Vy, r, mX, mY: real;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	148	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	149	EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	150	valueResult: LongInt;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	151	targXWrap, x, y, dX, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	152	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	153	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	154	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	155	Flags:= Flags; // avoid compiler hint
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	156	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	157	mY:= hwFloat2Float(Me^.Y);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	158	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	159	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	160	ap.ExplR:= 0;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	161	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	162	if (Targ.Point.X < mX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	163	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	164	else targXWrap:= Targ.Point.X - (RightX-LeftX);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	165	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	166	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	167	rTime:= rTime + 300 + Level * 50 + random(300);
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	168	if (WorldEdge = weWrap) and (random(2)=0) then
14212 ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	169	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	170	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	171	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	172	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	173	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	174	begin
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	175	x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	176	y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	177	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	178	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	179	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	180	repeat
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	181	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	182	x:= x + dX;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	183
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	184	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	185	dX:= dX + windSpeed;
13668 2b194214732d basic AI bazooka wrapping. nemo parents: 13472 diff changeset	186	//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	187	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	188	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	189	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	190	((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	191
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	192	EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	193	EY:= trunc(y);
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	194	if t >= -cExtraTime then
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	195	begin
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	196	if Level = 1 then
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	197	value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	198	else
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	199	value:= RateExplosion(Me, EX, EY, 101);
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	200	end else
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	201	value:= BadTurn;
545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	202
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	203	if (value = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
11476 c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	204	if GameFlags and gfSolidLand = 0 then
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	205	value := 1024 - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	206	else value := BadTurn;
14226 545b85c0f2e3 AI is bazooka genius unc0rr parents: 14220 diff changeset	207
14227 1d678dee55d1 fpc likes brackets nemo parents: 14226 diff changeset	208	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	209	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	210	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	211	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	212	ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	213	ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	214	ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	215	valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	216	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	217	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	218	until rTime > 5050 - Level * 800;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	219	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	220	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	221
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	222	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	223	var t: Longword;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	224	f: boolean;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	225	speed, d: real;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	226	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	227	// parabola flight before activation
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	228	t:= 500;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	229	repeat
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	230	x:= x + dx;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	231	y:= y + dy;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	232	dy:= dy + cGravityf;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	233	f:= ((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	234	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	235	dec(t)
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	236	until (t = 0) or (y >= cWaterLine) or f;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	237
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	238	if f then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	239	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	240	eX:= trunc(x);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	241	eY:= trunc(y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	242	exit(RateExplosion(Me, eX, eY, 101, afTrackFall or afErasesLand));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	243	end;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	244
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	245
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	246	// activated
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	247	t:= 5000;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	248	speed:= sqrt(sqr(dx) + sqr(dy));
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	249
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	250	repeat
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	251	if (t and $F) = 0 then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	252	begin
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	253	dx:= dx + 0.000064 * (tX - x);
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	254	dy:= dy + 0.000064 * (tY - y);
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	255	d := speed / sqrt(sqr(dx) + sqr(dy));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	256	dx:= dx * d;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	257	dy:= dy * d;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	258	end;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	259
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	260	x:= x + dx;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	261	y:= y + dy;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	262	f:= ((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	263	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	264	dec(t)
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	265	until (t = 0) or f;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	266
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	267	if f then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	268	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	269	eX:= trunc(x);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	270	eY:= trunc(y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	271	exit(RateExplosion(Me, eX, eY, 101, afTrackFall or afErasesLand));
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	272	end
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	273	else
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	274	calcBeeFlight:= BadTurn
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	275	end;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	276
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	277	function TestBee(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	278	var i, j: LongInt;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	279	valueResult, v, a, p: LongInt;
12621 d972b31f8881 fix some fpc hints sheepluva parents: 12193 diff changeset	280	mX, mY: real;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	281	eX, eY: LongInt;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	282	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	283	Flags:= Flags; // avoid compiler hint
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	284	if Level > 1 then
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	285	exit(BadTurn);
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	286
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	287	eX:= 0;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	288	eY:= 0;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	289	mX:= hwFloat2Float(Me^.X);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	290	mY:= hwFloat2Float(Me^.Y);
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	291	valueResult:= BadTurn;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	292	for i:= 0 to 8 do
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	293	for j:= 0 to 1 do
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	294	begin
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	295	a:= i * 120;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	296	p:= random(cMaxPower - 200) + 180;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	297
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	298	if j = 0 then
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	299	a:= -a;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	300
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	301	v:= calcBeeFlight(Me
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	302	, mX
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	303	, mY
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	304	, sin(a * pi / 2048) * p / cPowerDivisor
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	305	, -cos(a * pi / 2048) * p / cPowerDivisor
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	306	, Targ.Point.X
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	307	, Targ.Point.Y
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	308	, eX
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	309	, eY);
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	310
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	311	if v > valueResult then
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	312	begin
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	313	ap.ExplR:= 100;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	314	ap.ExplX:= eX;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	315	ap.ExplY:= eY;
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	316	ap.Angle:= a;
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	317	ap.Power:= p;
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	318	valueResult:= v
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	319	end
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	320	end;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	321
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	322	ap.AttackPutX:= Targ.Point.X;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	323	ap.AttackPutY:= Targ.Point.Y;
67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	324
11475 1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	325	if valueResult > 0 then
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	326	TestBee:= valueResult - 5000
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	327	else
1d478892cf1c AI is pretty good at using Bee weapon unc0rr parents: 11474 diff changeset	328	TestBee:= BadTurn // no digging
11474 67ae276ba229 Some WIP for bee unC0Rr parents: 11046 diff changeset	329	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	330
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	331	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	332	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	333	rTime: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	334	EX, EY: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	335	valueResult: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	336	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	337	t: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	338	value: LongInt;
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	339	t2: real;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	340	timer: Longint;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	341	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	342	Flags:= Flags; // avoid compiler hint
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	343	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	344
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	345	mX:= hwFloat2Float(Me^.X);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	346	mY:= hwFloat2Float(Me^.Y);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	347	ap.Time:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	348	rTime:= 350;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	349	ap.ExplR:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	350	valueResult:= BadTurn;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	351	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	352	if (Targ.Point.X < mX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	353	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	354	else targXWrap:= Targ.Point.X - (RightX-LeftX);
10637 13a5dd92ebf9 init timer to 0 nemo parents: 10108 diff changeset	355	timer:= 0;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	356	repeat
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	357	rTime:= rTime + 300 + Level * 50 + random(300);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	358	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	359	Vx:= - windSpeed * rTime * 0.5 + (targXWrap + AIrndSign(2) - mX) / rTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	360	else Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	361	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	362	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	363	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	364	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	365	x:= mX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	366	y:= mY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	367	dX:= Vx;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	368	dY:= -Vy;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	369	t:= rTime;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	370	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	371	x:= CheckWrap(x);
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	372	x:= x + dX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	373	y:= y + dY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	374	dX:= dX + windSpeed;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	375	dY:= dY + cGravityf;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	376	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	377	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	378	((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	379
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	380	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	381	begin
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	382	timer := 500;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	383	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	384	dX := dX * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	385	dY := dY * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	386	repeat
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	387	x:= x + dX;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	388	y:= y + dY;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	389	dec(timer);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	390	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	391	or (x < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	392	or (y < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	393	or (trunc(x) > LAND_WIDTH)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	394	or (trunc(y) > LAND_HEIGHT)
9136 78f087fd3e5b parsing ok, stops at uGears koda parents: 9127 diff changeset	395	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	396	or (timer = 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	397	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	398	EX:= trunc(x);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	399	EY:= trunc(y);
8862 85eb1f4b4a5f drill test tweak based on watching AI play nemo parents: 8824 diff changeset	400	// Try to prevent AI from thinking firing into water will cause a drowning
10637 13a5dd92ebf9 init timer to 0 nemo parents: 10108 diff changeset	401	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	402	if Level = 1 then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	403	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	404	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	405	if valueResult <= value then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	406	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	407	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	408	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	409	ap.ExplR:= 100;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	410	ap.ExplX:= EX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	411	ap.ExplY:= EY;
8824 fe9eacd390f2 Unbreak lua localisation, fix untranslated login prompt, update translations. nemo parents: 8822 diff changeset	412	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	413	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	414	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	415	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	416	TestDrillRocket:= valueResult
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	417	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	418
15611 be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	419	function TestRCPlane(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	420	const
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	421	MIN_RANGE = 200;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	422	var Vx, Vy, meX, meY, x, y: real;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	423	rx, ry, valueResult: LongInt;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	424	range, maxRange: integer;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	425	begin
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	426	// This is a very simple test to let a RC plane fly in a straight line, without dropping any bombs
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	427	// TODO: Teach AI how to steer
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	428	// TODO: Teach AI how to drop bombs
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	429	// TODO: Teach AI how to predict fire behavior
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	430	Flags:= Flags; // avoid compiler hint
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	431	if Level = 5 then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	432	exit(BadTurn)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	433	else if Level = 4 then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	434	maxRange:= 2200
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	435	else if Level = 3 then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	436	maxRange:= 2900
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	437	else if Level = 2 then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	438	maxRange:= 3500
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	439	else
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	440	maxRange:= 3900;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	441	TestRCPlane:= BadTurn;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	442	ap.ExplR:= 0;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	443	ap.Time:= 0;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	444	ap.Power:= 1;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	445	meX:= hwFloat2Float(Me^.X);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	446	meY:= hwFloat2Float(Me^.Y);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	447	x:= meX;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	448	y:= meY;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	449	range:= Metric(trunc(x), trunc(y), Targ.Point.X, Targ.Point.Y);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	450	if ( range < MIN_RANGE ) or ( range > maxRange) then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	451	exit(BadTurn);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	452
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	453	Vx:= (Targ.Point.X - x) * 1 / 1024;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	454	Vy:= (Targ.Point.Y - y) * 1 / 1024;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	455	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	456	repeat
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	457	x:= x + vX;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	458	y:= y + vY;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	459	rx:= trunc(x);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	460	ry:= trunc(y);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	461	if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 8)) or
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	462	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, rx, ry, 8)) then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	463	begin
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	464	x:= x + vX * 8;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	465	y:= y + vY * 8;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	466
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	467	// Intentionally low rating to discourage use
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	468	if Level = 1 then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	469	valueResult:= RateExplosion(Me, rx, ry, 26, afTrackFall or afErasesLand)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	470	else
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	471	valueResult:= RateExplosion(Me, rx, ry, 26);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	472
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	473	// Check range again in case the plane collided before target
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	474	range:= Metric(trunc(meX), trunc(meY), rx, ry);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	475	if ( range < MIN_RANGE ) or ( range > maxRange) then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	476	exit(BadTurn);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	477
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	478	// If impact location is close, above us and wind blows in our direction,
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	479	// there's a risk of fire flying towards us, so fail in this case.
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	480	if (Level < 3) and (range <= 600) and (meY >= ry) and
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	481	(((ap.Angle < 0) and (windSpeed > 0)) or ((ap.Angle > 0) and (windSpeed < 0))) then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	482	exit(BadTurn);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	483
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	484	if (valueResult <= 0) then
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	485	valueResult:= BadTurn;
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	486	exit(valueResult)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	487	end
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	488	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	489	or (x < 0)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	490	or (y < 0)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	491	or (trunc(x) > LAND_WIDTH)
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	492	or (trunc(y) > LAND_HEIGHT);
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	493
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	494	TestRCPlane:= BadTurn
be8fe5e0789e Teach AI to use RC plane (straight line only, no bombs) Wuzzy <Wuzzy2@mail.ru> parents: 15609 diff changeset	495	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	496
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	497	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	498	var Vx, Vy, r: real;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	499	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	500	EX, EY: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	501	valueResult: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	502	targXWrap, x, y, dX, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	503	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	504	value: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	505
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	506	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	507	Flags:= Flags; // avoid compiler hint
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	508	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	509	meY:= hwFloat2Float(Me^.Y);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	510	ap.Time:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	511	rTime:= 350;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	512	ap.ExplR:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	513	valueResult:= BadTurn;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	514	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	515	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	516	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	517	else targXWrap:= Targ.Point.X - (RightX-LeftX);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	518	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	519	rTime:= rTime + 300 + Level * 50 + random(1000);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	520	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	521	Vx:= - windSpeed * rTime * 0.5 + ((targXWrap + AIrndSign(2)) - meX) / rTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	522	else Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	523	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	524	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	525	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	526	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	527	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	528	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	529	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	530	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	531	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	532	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	533	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	534	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	535	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	536	dX:= dX + windSpeed;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	537	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	538	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	539	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	540	((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	541	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	542	EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	543
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	544	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	545	// LOL copypasta: this is score for digging with... snowball
5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	546	//if value = 0 then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	547	// 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	548
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	549	if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	550	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	551	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	552	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	553	ap.ExplR:= 0;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	554	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	555	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	556	valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	557	end;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	558	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	559	until (rTime > 5050 - Level * 800);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	560	TestSnowball:= valueResult
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	561	end;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	562
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	563	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	564	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	565	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	566	TestTime: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	567	targXWrap, x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	568	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	569	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	570	Flags:= Flags; // avoid compiler hint
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	571	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	572	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	573	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	574	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	575	ap.ExplR:= 0;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	576	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	577	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	578	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	579	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	580	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	581	inc(TestTime, 300);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	582	if (WorldEdge = weWrap) and (random(2)=0) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	583	Vx:= (targXWrap - meX) / TestTime
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	584	else Vx:= (Targ.Point.X - meX) / TestTime;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	585	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	586	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	587	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	588	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	589	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	590	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	591	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	592	t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	593	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	594	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	595	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	596	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	597	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	598	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	599	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	600	((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	601	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	602	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	603	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	604	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	605	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	606	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	607
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	608	if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	609	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	610	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	611	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	612	ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	613	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	614	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	615	valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	616	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	617	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	618	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	619	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	620	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	621
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	622	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	623	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	624	var Vx, Vy, r: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	625	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	626	TestTime: LongInt;
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	627	targXWrap, x, y, meX, meY, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	628	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	629	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	630	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	631	TestTime:= 0;
15602 583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	632	ap.Bounce:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	633	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	634	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	635	meY:= hwFloat2Float(Me^.Y);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	636	if (WorldEdge = weWrap) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	637	if (Targ.Point.X < meX) then
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	638	targXWrap:= Targ.Point.X + (RightX-LeftX)
c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	639	else targXWrap:= Targ.Point.X - (RightX-LeftX);
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	640	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	641	inc(TestTime, 1000);
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	642	if (WorldEdge = weWrap) and (random(2)=0) then
14212 ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	643	Vx:= (targXWrap + AIrndOffset(Targ, Level) - meX) / (TestTime + tDelta)
ca179b615c0b adding X offset seems to improve chance of drownings nemo parents: 14196 diff changeset	644	else Vx:= (Targ.Point.X + AIrndOffset(Targ, Level) - meX) / (TestTime + tDelta);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	645	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	646	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	647	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	648	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	649	x:= meX;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	650	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	651	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	652	t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	653	repeat
13669 c6ee1b0b957f more wrapping nemo parents: 13668 diff changeset	654	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	655	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	656	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	657	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	658	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	659	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	660	((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	661	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	662	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	663	if t < 50 then
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	664	if (Level = 1) and (Flags and amtest_NoTrackFall = 0) then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	665	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	666	else Score:= RateExplosion(Me, EX, EY, 101)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	667	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	668	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	669
8013 5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	670	if (valueResult < Score) and (Score > 0) then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	671	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	672	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 3));
b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	673	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	674	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	675	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	676	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	677	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	678	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	679	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	680	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	681	//until (Score > 204800) or (TestTime > 4000);
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	682	until TestTime > 4500 - Level * 512;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	683	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	684	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	685
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	686	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	687	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	688	var Vx, Vy, r: real;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	689	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	690	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	691	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	692	t: LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	693	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	694	Flags:= Flags; // avoid compiler hint
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	695	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	696	TestTime:= 500;
15602 583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	697	ap.Bounce:= 0;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	698	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	699	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	700	meY:= hwFloat2Float(Me^.Y);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	701	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	702	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	703	// 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	704	if meX<Targ.Point.X then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	705	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	706	else
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	707	Vx:= ((Targ.Point.X-10) - meX) / (TestTime + tDelta);
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	708	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	709	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	710	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	711	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	712	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	713	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	714	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	715	t:= TestTime;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	716	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	717	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	718	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	719	dY:= dY + cGravityf;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	720	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	721	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	722	((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	723	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	724	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	725	if t < 50 then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	726	Score:= RateExplosion(Me, EX, EY, 41)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	727	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	728	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	729
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	730	if Score > 0 then
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	731	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	732	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 2));
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	733	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	734	ap.Time:= TestTime div 1000 * 1000;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	735	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	736	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	737	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	738	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	739	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	740	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	741	until (TestTime = 4100);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	742	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	743	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	744
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	745	function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	746	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	747	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	748	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	749	TestTime: Longword;
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	750	targXWrap, x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	751	t: LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	752	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	753	Flags:= Flags; // avoid compiler hint
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	754	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	755	TestTime:= 500;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	756	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	757	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	758	meY:= hwFloat2Float(Me^.Y);
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	759	if (WorldEdge = weWrap) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	760	if (Targ.Point.X < meX) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	761	targXWrap:= Targ.Point.X + (RightX-LeftX)
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	762	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	763	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	764	inc(TestTime, 900);
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	765	if (WorldEdge = weWrap) and (random(2)=0) then
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	766	Vx:= (targXWrap - meX) / (TestTime + tDelta)
7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	767	else Vx:= (Targ.Point.X - meX) / (TestTime + tDelta);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	768	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	769	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	770	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	771	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	772	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	773	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	774	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	775	t:= TestTime;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	776	repeat
13671 7a31a292fa84 and melon for Mutant nemo parents: 13670 diff changeset	777	x:= CheckWrap(x);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	778	x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	779	y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	780	dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	781	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	782	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	783	((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	784
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	785	EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	786	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	787	if t < 50 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	788	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	789	else
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	790	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	791
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	792	if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	793	begin
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	794	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	795	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	796	ap.Time:= TestTime div 1000 * 1000;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	797	ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	798	ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	799	ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	800	valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	801	end;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	802	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	803	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	804	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	805	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	806
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	807
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	808	function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	809	var A, B, D, T: real;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	810	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	811	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	812	A:= sqr(cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	813	B:= - cGravityf * (TY - MY) - 1;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	814	C:= sqr(TY - MY) + sqr(TX - MX);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	815	D:= sqr(B) - A * C;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	816	if D >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	817	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	818	D:= sqrt(D) - B;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	819	if D >= 0 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	820	T:= sqrt(D * 2 / A)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	821	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	822	T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	823	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	824	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	825	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	826	Solve:= 0
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	827	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	828
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	829	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	830	//const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	831	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	832	Score, EX, EY: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	833	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	834	x, y, dY, meX, meY: real;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	835	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	836	Flags:= Flags; // avoid compiler hint
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	837	TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	838	ap.ExplR:= 0;
7790 040fc517fece - Fix desyncs triggered by AI unc0rr parents: 7789 diff changeset	839
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	840	meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	841	meY:= hwFloat2Float(Me^.Y);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	842
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	843	if (Level > 2) then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	844	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	845
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	846	TestTime:= Solve(Targ.Point.X, Targ.Point.Y, trunc(meX), trunc(meY));
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	847
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	848	if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	849	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	850
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	851	Vx:= (Targ.Point.X - meX) / TestTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	852	Vy:= cGravityf * (TestTime div 2) - (Targ.Point.Y - meY) / TestTime;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	853
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	854	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	855	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	856	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	857
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	858	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	859	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	860	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	861	dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	862	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	863	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	864	until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	865	((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	866
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	867	if (EY < cWaterLine) and (dY >= 0) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	868	begin
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	869	Score:= RateExplosion(Me, EX, EY, 91);
9005 15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	870	if (Score = 0) then
15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	871	if (dY > 0.15) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	872	Score:= - abs(Targ.Point.Y - EY) div 32
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	873	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	874	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	875	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	876	Score:= BadTurn
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	877	end
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	878	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	879	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	880
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	881	if Score > 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	882	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	883	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	884	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	885	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	886	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	887	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	888	TestMortar:= Score
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	889	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	890	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	891
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	892	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	893	const
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	894	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	895	MAX_RANGE = 400;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	896	var Vx, Vy, x, y: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	897	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	898	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	899	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	900	Flags:= Flags; // avoid compiler hint
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	901	TestShotgun:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	902	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	903	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	904	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	905	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	906	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	907	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	908	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	909	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	910
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	911	Vx:= (Targ.Point.X - x) * 1 / 1024;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	912	Vy:= (Targ.Point.Y - y) * 1 / 1024;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	913	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	914	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	915	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	916	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	917	rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	918	ry:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	919	if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	920	((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	921	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	922	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	923	y:= y + vY * 8;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	924	valueResult:= RateShotgun(Me, vX, vY, rx, ry);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	925
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	926	if (valueResult = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
11476 c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	927	begin
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	928	if GameFlags and gfSolidLand = 0 then
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	929	valueResult:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, rx, ry) div 64
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	930	else valueResult := BadTurn
c4e1d39acc56 Disable digging on solid land nemo parents: 11475 diff changeset	931	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	932	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	933	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	934	// 27/20 is reuse bonus
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	935	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	936	end
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	937	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	938	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	939	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	940	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	941	or (trunc(y) > LAND_HEIGHT);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	942
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	943	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	944	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	945
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	946	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): 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	947	var Vx, Vy, x, y, t: real;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	948	d: Longword;
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	949	ix, iy, valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	950	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	951	Flags:= Flags; // avoid compiler hint
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	952	if (Level > 4) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn);
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	953	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	954	ap.ExplR:= 1;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	955	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	956	ap.Power:= 1;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	957
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	958	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	959	y:= hwFloat2Float(Me^.Y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	960
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	961	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	962	exit(BadTurn);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	963
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	964	t:= 2 / sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y));
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	965	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	966	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	967	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	968	d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	969
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	970	ix:= trunc(x);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	971	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	972
10097 acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	973	if ((ix and LAND_WIDTH_MASK) = 0) and ((iy and LAND_HEIGHT_MASK) = 0) then
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	974	repeat
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	975	if Land[iy, ix] <> 0 then
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	976	inc(d);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	977	x:= x + vX;
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	978	y:= y + vY;
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	979	ix:= trunc(x);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	980	iy:= trunc(y);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	981	until (Abs(Targ.Point.X - ix) + Abs(Targ.Point.Y - iy) < 5)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	982	or (x < 0)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	983	or (y < 0)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	984	or (ix >= LAND_WIDTH)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	985	or (iy >= LAND_HEIGHT)
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	986	or (d > 48);
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	987
acef073e190f Tiny optimization unc0rr parents: 10015 diff changeset	988	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	989	begin
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	990	ap.AttacksNum:= 1 + (d + 8) div 12;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	991	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	992	end
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	993	else
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	994	valueResult:= BadTurn;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	995
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	996	TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	997	end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	998
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	999
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1000	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): 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	1001	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	1002	d: Longword;
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	1003	//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	1004	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1005	Flags:= Flags; // avoid compiler hint
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	1006	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	1007	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	1008	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	1009	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	1010	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	1011	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	1012	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1013	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	1014	exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	1015
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1016	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	1017	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	1018	dmg:= dmg * 0.025; // div 40
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1019	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1020	Vy:= (Targ.Point.Y - y) * t;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	1021	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	1022	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	1023
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	1024	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1025	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	1026	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1027	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	1028	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	1029	inc(d);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1030	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	1031	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1032	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1033	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1034	or (trunc(y) > LAND_HEIGHT)
7873 266fe9f1e5a9 Improve TestSniperRifle a bit unc0rr parents: 7790 diff changeset	1035	or (d > 22);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	1036
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1037	if Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4 then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1038	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	1039	else TestSniperRifle:= BadTurn;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	1040	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	1041
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	1042
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1043	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1044	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	1045	x, y, trackFall: LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1046	dx, dy: real;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	1047	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1048	Flags:= Flags; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1049	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1050
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1051	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	1052	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1053
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1054	ap.ExplR:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1055	ap.Time:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1056	ap.Power:= 1;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1057	x:= hwRound(Me^.X);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1058	y:= hwRound(Me^.Y);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1059
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	1060	a:= cMaxAngle div 2;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1061	valueResult:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1062
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	1063	while a >= 0 do
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1064	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1065	dx:= sin(a / cMaxAngle * pi) * 0.5;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1066	dy:= cos(a / cMaxAngle * pi) * 0.5;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	1067
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1068	v1:= RateShove(Me, x - 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1069	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1070	, -dx, -dy, trackFall);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1071	v2:= RateShove(Me, x + 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1072	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1073	, dx, -dy, trackFall);
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1074	if (v1 > valueResult) or (v2 > valueResult) then
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1075	if (v2 > v1)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1076	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1077	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1078	ap.Angle:= a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1079	valueResult:= v2
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1080	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1081	else
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1082	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1083	ap.Angle:= -a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1084	valueResult:= v1
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1085	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	1086
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	1087	a:= a - 15 - random(cMaxAngle div 16)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1088	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1089
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1090	if valueResult <= 0 then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1091	valueResult:= BadTurn;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1092
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	1093	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	1094	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	1095
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1096	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1097	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	1098	x, y, trackFall: LongInt;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	1099	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1100	Flags:= Flags; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1101	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1102
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1103	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	1104	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1105
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1106	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1107	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1108	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1109	x:= hwRound(Me^.X);
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1110	y:= hwRound(Me^.Y) + 4;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1111
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1112	v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1113	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1114	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1115	v1:= v1 + RateShove(Me, x - 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1116	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1117	, -0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1118	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1119	v1:= v1 + RateShove(Me, x - 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1120	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1121	, -0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1122
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	1123
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1124	// now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1125	v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1126	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1127	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1128	v2:= v2 + RateShove(Me, x + 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1129	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1130	, 0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1131	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1132	v2:= v2 + RateShove(Me, x + 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	1133	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1134	, 0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1135
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1136	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1137	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	1138	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1139	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1140	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1141	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1142	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1143	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1144	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1145	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1146	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1147
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1148	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1149	valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1150
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1151	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	1152	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	1153
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	1154
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1155	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1156	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	1157	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	1158	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1159	Flags:= Flags; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1160	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1161
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1162	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	1163	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1164
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1165	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1166	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1167	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1168	x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1169	y:= hwRound(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1170
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1171	// check left direction
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1172	{first RateShove checks farthermost of two whip's AmmoShove attacks
13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1173	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	1174	RateShove call)}
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1175	v1:= RateShove(Me, x - 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1176	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1177	, -1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1178	v1:= v1 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1179	RateShove(Me, x - 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1180	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1181	, -1, -0.8, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1182	// now try opposite direction
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1183	v2:= RateShove(Me, x + 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1184	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1185	, 1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1186	v2:= v2 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1187	RateShove(Me, x + 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	1188	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	1189	, 1, -0.8, trackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	1190
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1191	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1192	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	1193	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1194	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1195	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1196	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1197	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1198	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1199	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1200	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1201	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1202
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1203	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1204	valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1205	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1206	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	1207
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	1208	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	1209	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	1210
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1211	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1212	const step = 8;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1213	var valueResult, i, v, tx: LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1214	trackFall: LongInt;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1215	t, d, x, y, dx, dy, cx: real;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1216	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1217	Flags:= Flags; // avoid compiler hint
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1218	ap.ExplR:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1219	ap.Time:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1220	ap.Power:= 1;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1221
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1222	if Level = 1 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1223	trackFall:= afTrackFall
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1224	else if Level = 2 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1225	trackFall:= 0
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1226	else
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1227	exit(BadTurn);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1228
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1229	valueResult:= 0;
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1230	v:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1231
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1232	x:= hwFloat2Float(Me^.X);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1233	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1234	d:= sqrt(sqr(Targ.Point.X - x) + sqr(Targ.Point.Y - y));
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1235	if d < 10 then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1236	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1237	dx:= 0;
14547 90893b397933 Fix dy hardcoded value in kamikaze test unc0rr parents: 14546 diff changeset	1238	dy:= step;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1239	ap.Angle:= 2048
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1240	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1241	else
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1242	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1243	t:= step / d;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1244	dx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1245	dy:= (Targ.Point.Y - y) * t;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1246
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1247	ap.Angle:= DxDy2AttackAnglef(dx, -dy)
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1248	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1249
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1250	if dx >= 0 then cx:= 0.45 else cx:= -0.45;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1251
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1252	for i:= 1 to 512 div step - 2 do
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1253	begin
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1254	x:= x + dx;
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1255	y:= y + dy;
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1256
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1257	valueResult:= valueResult +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1258	RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1259	, 30, 30, 25
15608 308930fe5f4a AI: Remove own gear from explosion/shove checks in kami/piano test Wuzzy <Wuzzy2@mail.ru> parents: 15607 diff changeset	1260	, cx, -0.9, trackFall or afSetSkip or afIgnoreMe);
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1261	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1262
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1263	if (d < 10) and (dx = 0) then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1264	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1265	x:= hwFloat2Float(Me^.X);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1266	y:= hwFloat2Float(Me^.Y);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1267	tx:= trunc(x);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1268	v:= RateShove(Me, tx, trunc(y)
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	1269	, 30, 30, 25
15608 308930fe5f4a AI: Remove own gear from explosion/shove checks in kami/piano test Wuzzy <Wuzzy2@mail.ru> parents: 15607 diff changeset	1270	, -cx, -0.9, trackFall or afIgnoreMe);
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1271	for i:= 1 to 512 div step - 2 do
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1272	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1273	y:= y + dy;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1274	v:= v +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1275	RateShove(Me, tx, trunc(y)
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1276	, 30, 30, 25
15608 308930fe5f4a AI: Remove own gear from explosion/shove checks in kami/piano test Wuzzy <Wuzzy2@mail.ru> parents: 15607 diff changeset	1277	, -cx, -0.9, trackFall or afSetSkip or afIgnoreMe);
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1278	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1279	end;
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1280
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1281	if v > valueResult then
14546 7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1282	begin
7e4862823649 Fix broken kamikaze logic when target position is close to attacker unc0rr parents: 14227 diff changeset	1283	cx:= -cx;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1284	ap.Angle:= -2048;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1285	valueResult:= v
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1286	end;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1287
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1288	v:= RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1289	, 30, 30, 25
15608 308930fe5f4a AI: Remove own gear from explosion/shove checks in kami/piano test Wuzzy <Wuzzy2@mail.ru> parents: 15607 diff changeset	1290	, cx, -0.9, trackFall or afIgnoreMe);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1291	valueResult:= valueResult + v - KillScore * friendlyfactor div 100 * 1024;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1292
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1293	if v < 65536 then
15608 308930fe5f4a AI: Remove own gear from explosion/shove checks in kami/piano test Wuzzy <Wuzzy2@mail.ru> parents: 15607 diff changeset	1294	inc(valueResult, RateExplosion(Me, trunc(x), trunc(y), 30, afIgnoreMe));
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1295
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1296	TestKamikaze:= valueResult;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1297	end;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1298
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1299	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1300	var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1301	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1302	Flags:= Flags; // avoid compiler hint
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1303	Level:= Level; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1304	Targ:= Targ;
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1305
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1306	ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1307	ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1308	ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1309	ap.Angle:= 0;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1310
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	1311	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	1312	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	1313	rate:= BadTurn;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1314	TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1315	end;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1316
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1317	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	1318	const cShift = 4;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1319	var bombsSpeed, X, Y, dY: real;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1320	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1321	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1322	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1323	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1324	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1325	Flags:= Flags; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1326	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1327	ap.Time:= 0;
9844 8f5b48525a03 quick sanity change for AI + zerog nemo parents: 9790 diff changeset	1328	if (Level > 3) or (cGravityf = 0) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1329	exit(BadTurn);
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	1330
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	1331	ap.Angle:= 0;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1332	ap.AttackPutX:= Targ.Point.X;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1333	ap.AttackPutY:= Targ.Point.Y;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1334
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1335	bombsSpeed:= hwFloat2Float(cBombsSpeed);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1336	X:= Targ.Point.X - 135 - cShift; // hh center - cShift
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1337	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	1338	Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1339	dY:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1340
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1341	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1342	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1343	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1344	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1345	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1346	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1347
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1348	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1349	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	1350	Y:= Y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1351	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	1352	fexit:= true;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1353
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1354	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	1355	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	1356	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1357	fexit:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1358	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	1359	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1360	b[i]:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1361	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	1362	// 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	1363	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1364	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1365	until fexit or (Y > cWaterLine);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1366
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1367	for i:= 0 to 5 do
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1368	if dmg[i] <> BadTurn then
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1369	inc(valueResult, dmg[i]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1370	t:= valueResult;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1371	ap.AttackPutX:= Targ.Point.X - 60;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1372
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1373	for i:= 0 to 3 do
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1374	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	1375	begin
13472 d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1376	dec(t, dmg[i]);
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1377	inc(t, dmg[i + 6]);
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1378	if t > valueResult then
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1379	begin
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1380	valueResult:= t;
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1381	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	1382	end
d3209e0caf12 Fix aihDoesntMatter still being attacked with air attack Wuzzy <Wuzzy2@mail.ru> parents: 13463 diff changeset	1383	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1384
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1385	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	1386	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1387	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1388	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1389
15603 ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1390	function TestDrillStrike(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1391	const cShift = 4;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1392	var bombsSpeed, X, Y, dX, dY, drillX, drillY: real;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1393	t2: real;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1394	b: array[0..9] of boolean;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1395	dmg: array[0..9] of LongInt;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1396	fexit, collided: boolean;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1397	i, t, value, valueResult, attackTime, drillTimer, targetX: LongInt;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1398	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1399	Flags:= Flags; // avoid compiler hint
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1400	ap.ExplR:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1401	if (Level > 3) or (cGravityf = 0) then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1402	exit(BadTurn);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1403
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1404	ap.Angle:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1405	targetX:= Targ.Point.X;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1406	ap.AttackPutY:= Targ.Point.Y;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1407
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1408	bombsSpeed:= hwFloat2Float(cBombsSpeed);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1409	X:= Targ.Point.X - 135 - cShift; // hh center - cShift
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1410	X:= X - bombsSpeed * sqrt(((Targ.Point.Y + 128) * 2) / cGravityf);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1411	Y:= -128;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1412	dX:= bombsSpeed;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1413	dY:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1414
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1415	valueResult:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1416
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1417	attackTime:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1418	while attackTime <= 4000 do
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1419	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1420	inc(attackTime, 1000);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1421	value:= 0;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1422	for i:= 0 to 9 do
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1423	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1424	b[i]:= true;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1425	dmg[i]:= 0
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1426	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1427
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1428	repeat
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1429	X:= X + dX;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1430	Y:= Y + dY;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1431	dY:= dY + cGravityf;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1432	fexit:= true;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1433
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1434	for i:= 0 to 9 do
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1435	if b[i] then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1436	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1437	fexit:= false;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1438	collided:= false;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1439	drillX:= trunc(X) + LongWord(i * 30);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1440	drillY:= trunc(Y);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1441	// Collided with land ... simulate drilling
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1442	if TestCollExcludingObjects(trunc(drillX), trunc(drillY), 4) and
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1443	(Abs(Targ.Point.X - trunc(X)) + Abs(Targ.Point.Y - trunc(Y)) > 21) then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1444	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1445	drillTimer := attackTime;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1446	t2 := 0.5 / sqrt(sqr(dX) + sqr(dY));
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1447	dX := dX * t2;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1448	dY := dY * t2;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1449	repeat
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1450	drillX:= drillX + dX;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1451	drillY:= drillY + dY;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1452	dec(drillTimer, 10);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1453	until (Abs(Targ.Point.X - drillX) + Abs(Targ.Point.Y - drillY) < 22)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1454	or (drillX < 0)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1455	or (drillY < 0)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1456	or (trunc(drillX) > LAND_WIDTH)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1457	or (trunc(drillY) > LAND_HEIGHT)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1458	// TODO: Simulate falling again when rocket has left terrain again
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1459	or (drillTimer <= 0);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1460	collided:= true;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1461	end
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1462	// Collided with something else ... record collision
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1463	else if TestColl(trunc(drillX), trunc(drillY), 4) then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1464	collided:= true;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1465
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1466	// Simulate explosion
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1467	if collided then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1468	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1469	b[i]:= false;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1470	dmg[i]:= RateExplosion(Me, trunc(drillX), trunc(drillY), 58);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1471	// 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets)
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1472	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1473	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1474	until fexit or (Y > cWaterLine);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1475
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1476	for i:= 0 to 5 do
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1477	if dmg[i] <> BadTurn then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1478	inc(value, dmg[i]);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1479	t:= value;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1480	targetX:= Targ.Point.X - 60;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1481
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1482	for i:= 0 to 3 do
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1483	if dmg[i] <> BadTurn then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1484	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1485	dec(t, dmg[i]);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1486	inc(t, dmg[i + 6]);
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1487	if t > value then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1488	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1489	value:= t;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1490	targetX:= Targ.Point.X - 30 - cShift + i * 30
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1491	end
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1492	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1493
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1494	if value > valueResult then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1495	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1496	valueResult:= value;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1497	ap.AttackPutX:= targetX;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1498	ap.Time:= attackTime;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1499	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1500	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1501
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1502	if valueResult <= 0 then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1503	valueResult:= BadTurn
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1504	else
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1505	begin
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1506	// Weaker AI has chance to get the time wrong by 1-3 seconds
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1507	if Level = 5 then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1508	// +/- 3 seconds
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1509	ap.Time:= ap.Time + (3 - random(7)) * 1000
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1510	else if Level = 4 then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1511	// +/- 2 seconds
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1512	ap.Time:= ap.Time + (2 - random(5)) * 1000
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1513	else if Level = 3 then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1514	// +/- 1 second
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1515	if (random(2) = 0) then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1516	ap.Time:= ap.Time + (1 - random(3)) * 1000
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1517	else if Level = 2 then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1518	// 50% chance for +/- 1 second
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1519	if (random(2) = 0) then
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1520	ap.Time:= ap.Time + (1 - random(3)) * 1000;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1521	ap.Time:= Min(5000, Max(1000, ap.Time));
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1522	end;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1523
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1524	TestDrillStrike:= valueResult;
ac44dae6425e Teach AI to use drill strike Wuzzy <Wuzzy2@mail.ru> parents: 15602 diff changeset	1525	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1526
15604 22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1527	function TestMineStrike(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1528	const cShift = 4;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1529	var minesSpeed, X, Y, dY: real;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1530	b: array[0..9] of boolean;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1531	dmg: array[0..9] of LongInt;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1532	fexit: boolean;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1533	i, t, valueResult: LongInt;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1534	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1535	Flags:= Flags; // avoid compiler hint
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1536	ap.ExplR:= 0;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1537	ap.Time:= 0;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1538
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1539	// AI currently only supports cMinesTime = 0 because it's the most
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1540	// predictable.
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1541	// Other cMinesTime values are risky because of bouncy mines;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1542	// so they are unsupported.
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1543	// TODO: Implement mine strike for other values of MineTime
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1544	// TODO: Teach AI to avoid hitting their own with mines
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1545	if (Level > 3) or (cGravityf = 0) or (cMinesTime <> 0) then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1546	exit(BadTurn);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1547
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1548	ap.Angle:= 0;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1549	ap.AttackPutX:= Targ.Point.X;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1550	ap.AttackPutY:= Targ.Point.Y;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1551
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1552	minesSpeed:= hwFloat2Float(cBombsSpeed);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1553	X:= Targ.Point.X - 135 - cShift; // hh center - cShift
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1554	X:= X - minesSpeed * sqrt(((Targ.Point.Y + 128) * 2) / cGravityf);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1555	Y:= -128;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1556	dY:= 0;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1557
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1558	for i:= 0 to 9 do
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1559	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1560	b[i]:= true;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1561	dmg[i]:= 0
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1562	end;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1563	valueResult:= 0;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1564
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1565	repeat
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1566	X:= X + minesSpeed;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1567	Y:= Y + dY;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1568	dY:= dY + cGravityf;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1569	fexit:= true;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1570
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1571	for i:= 0 to 9 do
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1572	if b[i] then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1573	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1574	fexit:= false;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1575	if TestColl(trunc(X) + LongWord(i * 30), trunc(Y), 4) then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1576	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1577	b[i]:= false;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1578	dmg[i]:= RateExplosion(Me, trunc(X) + LongWord(i * 30), trunc(Y), 96)
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1579	end
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1580	end;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1581	until fexit or (Y > cWaterLine);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1582
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1583	for i:= 0 to 5 do
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1584	if dmg[i] <> BadTurn then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1585	inc(valueResult, dmg[i]);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1586	t:= valueResult;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1587	ap.AttackPutX:= Targ.Point.X - 60;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1588
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1589	for i:= 0 to 3 do
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1590	if dmg[i] <> BadTurn then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1591	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1592	dec(t, dmg[i]);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1593	inc(t, dmg[i + 6]);
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1594	if t > valueResult then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1595	begin
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1596	valueResult:= t;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1597	ap.AttackPutX:= Targ.Point.X - 30 - cShift + i * 30
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1598	end
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1599	end;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1600
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1601	if valueResult <= 0 then
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1602	valueResult:= BadTurn;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1603	TestMineStrike:= valueResult;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1604	end;
22d0a3d6e2be Teach AI how to use MineStrike (0 secs only) Wuzzy <Wuzzy2@mail.ru> parents: 15603 diff changeset	1605
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1606	function TestPiano(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1607	const BOUNCES = 5;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1608	var X, Y: real;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1609	dmg: array[0..BOUNCES-1] of LongInt;
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1610	i, e, rate, valueResult: LongInt;
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1611	begin
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1612	Flags:= Flags; // avoid compiler hint
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1613	ap.ExplR:= 0;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1614	ap.Time:= 0;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1615	if (cGravityf <= 0) then
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1616	exit(BadTurn);
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1617
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1618	if (Level > 2) then
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1619	exit(BadTurn);
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1620
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1621	ap.Angle:= 0;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1622	ap.AttackPutX:= Targ.Point.X;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1623	ap.AttackPutY:= Targ.Point.Y;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1624
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1625	X:= Targ.Point.X;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1626	Y:= -128;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1627
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1628	for i:= 0 to BOUNCES-1 do
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1629	dmg[i]:= 0;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1630
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1631	i:= 1;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1632	repeat
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1633	// Piano goes down
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1634	Y:= Y + 11;
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1635	if TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(X), trunc(Y), 32) then
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1636	begin
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1637	for e:= -1 to 1 do
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1638	begin
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1639	rate:= RateExplosion(Me, trunc(X) + 30*e, trunc(Y)+40, 161, afIgnoreMe);
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1640	if rate <> BadTurn then
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1641	dmg[i]:= dmg[i] + rate;
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1642	end;
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1643
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1644	if (i > 1) and (dmg[i] > 0) then
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1645	dmg[i]:= dmg[i] div 2;
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1646	inc(i);
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1647	// Skip past the blast hole
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1648	Y:= Y + 41
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1649	end;
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1650	until (i > BOUNCES) or (Y > cWaterLine);
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1651
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1652	if (i = 0) and (Y > cWaterLine) then
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1653	exit(BadTurn);
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1654
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1655	valueResult:= 0;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1656	for i:= 0 to BOUNCES do
15609 4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1657	if dmg[i] <= BadTurn then
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1658	begin
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1659	valueResult:= BadTurn;
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1660	break;
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1661	end
4ae2ebe812be AI: Tweak piano test Wuzzy <Wuzzy2@mail.ru> parents: 15608 diff changeset	1662	else
15607 899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1663	inc(valueResult, dmg[i]);
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1664	ap.AttackPutX:= Targ.Point.X;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1665
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1666	valueResult:= valueResult - KillScore * friendlyfactor div 100 * 1024;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1667
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1668	if valueResult <= 0 then
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1669	valueResult:= BadTurn;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1670	TestPiano:= valueResult;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1671	end;
899fd1841399 Teach AI to use piano strike Wuzzy <Wuzzy2@mail.ru> parents: 15604 diff changeset	1672
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1673	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1674	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1675	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1676	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1677	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1678	Flags:= Flags; // avoid compiler hint
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1679	TestTeleport := BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1680	exit(BadTurn);
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1681	Level:= Level; // avoid compiler hint
6888 32a54322d262 Get rid of TGearsType to simplify pas2c unc0rr parents: 6879 diff changeset	1682	//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	1683	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	1684	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1685	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	1686	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1687	maxTop := Targ.Point.Y - cHHRadius * 2;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1688
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1689	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	1690	dec(maxTop, cHHRadius*2);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1691	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	1692	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1693	ap.AttackPutX := Targ.Point.X;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1694	ap.AttackPutY := maxTop + cHHRadius;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1695	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	1696	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1697	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1698	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1699	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1700	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1701	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	1702	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1703	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1704	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	1705	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	1706	or (failNum = bonuses.Count*2);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1707
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1708	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	1709	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1710	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1711	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1712	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	1713	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1714	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1715	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1716
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1717
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	1718	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	1719	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	1720	v: LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1721	begin
8370 0c79946e96f8 Fix tons of warnings martin_bede parents: 8161 diff changeset	1722	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	1723	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	1724
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	1725	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	1726	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	1727	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	1728	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	1729	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	1730	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	1731	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	1732	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	1733	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	1734	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	1735	end;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1736	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1737
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1738	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1739	var valueResult, v1, v2: LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1740	cake: TGear;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1741	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1742	Flags:= Flags; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1743	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1744
7501 1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1745	if (Level > 2) then
1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1746	exit(BadTurn);
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1747
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1748	ap.ExplR:= 0;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1749	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	1750	ap.Power:= BadTurn; // use it as max score value in checkCakeWalk
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1751
7721 2b1ad418ba39 - Fix warnings and hints unc0rr parents: 7716 diff changeset	1752	//FillChar(cake, sizeof(cake), 0);
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1753	cake.Radius:= 7;
13463 f1d349a52bc7 Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate Wuzzy <Wuzzy2@mail.ru> parents: 12898 diff changeset	1754	cake.CollisionMask:= lfNotCurHogCrate;
7752 65bacd3ba69e Fix crasher in TestCake unc0rr parents: 7730 diff changeset	1755	cake.Hedgehog:= Me^.Hedgehog;
15366 381c828865e7 Fix a couple more uses of uninitialized variables unC0Rr parents: 14586 diff changeset	1756	cake.Kind:= gtCake;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1757
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1758	// check left direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1759	cake.Angle:= 3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1760	cake.dX.isNegative:= true;
15366 381c828865e7 Fix a couple more uses of uninitialized variables unC0Rr parents: 14586 diff changeset	1761	cake.dX.QWordValue:= 0;
381c828865e7 Fix a couple more uses of uninitialized variables unC0Rr parents: 14586 diff changeset	1762	cake.dY:= _0;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1763	cake.X:= Me^.X - _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1764	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	1765	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	1766	v1:= ap.Power;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1767
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1768	// now try opposite direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1769	cake.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1770	cake.dX.isNegative:= false;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1771	cake.X:= Me^.X + _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1772	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	1773	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	1774	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	1775
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	1776	ap.Power:= 1;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1777
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1778	if (v2 > v1) then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1779	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1780	ap.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1781	valueResult:= v2
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1782	end
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1783	else
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1784	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1785	ap.Angle:= -1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1786	valueResult:= v1
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1787	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1788
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1789	if valueResult <= 0 then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1790	valueResult:= BadTurn;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1791
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1792	TestCake:= valueResult;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1793	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1794
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1795	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): 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	1796	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	1797	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	1798	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	1799	begin
15524 fbcee515b946 disable fall tracing for cheese. it will probably be incorrect. nemo parents: 15366 diff changeset	1800	Flags:= Flags; // avoid compiler hint
9790 0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1801	Targ:= Targ; // avoid compiler hint
0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1802
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	1803	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	1804	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	1805	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	1806	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	1807	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	1808	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	1809	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	1810	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	1811	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	1812	y:= y + dy;
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1813
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	1814	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	1815	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	1816	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	1817
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	1818	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	1819	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	1820
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	1821	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	1822	valueResult:= RateExplosion(Me, EX, EY, 76, afTrackFall or afErasesLand)
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1823	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	1824	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	1825
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	1826	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	1827	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	1828	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	1829	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	1830	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	1831	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	1832	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	1833	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	1834	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	1835	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	1836
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	1837	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	1838	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	1839
15600 7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1840	function TestMine(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams; Flags: LongWord): LongInt;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1841	var valueResult: LongInt;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1842	x, y, dx, dy: real;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1843	EX, EY, t: LongInt;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1844	begin
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1845	Flags:= Flags; // avoid compiler hint
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1846	Targ:= Targ; // avoid compiler hint
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1847
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1848	x:= hwFloat2Float(Me^.X) + hwSign(Me^.dX) * 7;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1849	y:= hwFloat2Float(Me^.Y);
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1850	dx:= hwSign(Me^.dX) * 0.02;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1851	dy:= 0;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1852	t:= 10000;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1853	repeat
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1854	dec(t);
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1855	x:= x + dx;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1856	dy:= dy + cGravityf;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1857	y:= y + dy;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1858	if ((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 2)) or
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1859	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 2)) then
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1860	t:= 0;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1861	until t = 0;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1862
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1863	EX:= trunc(x);
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1864	EY:= trunc(y);
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1865
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1866	if Level = 1 then
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1867	valueResult:= RateExplosion(Me, EX, EY, 51, afTrackFall or afErasesLand)
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1868	else
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1869	valueResult:= RateExplosion(Me, EX, EY, 51);
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1870
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1871	if (valueResult > 0) then
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1872	begin
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1873	ap.Angle:= 0;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1874	ap.Power:= 1;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1875	ap.Time:= 0;
15602 583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	1876	if (Level < 5) then
583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	1877	// Set minimum mine bounciness for improved aim
583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	1878	ap.Bounce:= 1
583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	1879	else
583080b0272b AI: Refactor bounce handling Wuzzy <Wuzzy2@mail.ru> parents: 15600 diff changeset	1880	ap.Bounce:= 0;
15600 7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1881	ap.ExplR:= 100;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1882	ap.ExplX:= EX;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1883	ap.ExplY:= EY
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1884	end else
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1885	valueResult:= BadTurn;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1886
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1887	TestMine:= valueResult
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1888	end;
7d3877231b00 Teach AI to drop mines from safe height Wuzzy <Wuzzy2@mail.ru> parents: 15524 diff changeset	1889
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	1890	end.

author	Wuzzy <Wuzzy2@mail.ru>
	Mon, 08 Jun 2020 21:13:31 +0200
changeset 15611	be8fe5e0789e
parent 15609	4ae2ebe812be
child 15612	39a353e8ef3d
permissions	-rw-r--r--