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

author	Wuzzy <Wuzzy2@mail.ru>
	Thu, 25 Jun 2020 06:44:35 +0200
changeset 15634	21dece8f55fe
parent 15619	92ce801d0681
child 15636	34c32a11203e
permissions	-rw-r--r--