sheepy-clone: hedgewars/uAIAmmoTests.pas@682e21112867 (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
6700 e04da46ee43c the most important commit of the year koda parents: 6580 diff changeset	3	* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com>
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	4	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	5	* This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	6	* it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	7	* the Free Software Foundation; version 2 of the License
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	8	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	9	* This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	12	* GNU General Public License for more details.
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	13	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	14	* You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	15	* along with this program; if not, write to the Free Software
57c2ef19f719 Relicense to GPL unc0rr parents: 143 diff changeset	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
71 5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	17	*)
5f56c6979496 - Changed falling damage scoring unc0rr parents: 70 diff changeset	18
2630 079ef82eac75 revamped file access and debug display koda parents: 2616 diff changeset	19	{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display koda parents: 2616 diff changeset	20
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	21	unit uAIAmmoTests;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	22	interface
4357 a1fcfc341a52 Introduce unit uTypes in order to remove some cyclic unit dependencies unC0Rr parents: 4317 diff changeset	23	uses SDLh, uConsts, uFloat, uTypes;
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	24	const
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	25	amtest_OnTurn = $00000001; // from one position
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	26	amtest_NoTarget = $00000002; // each pos, but no targetting
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	27
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	28	var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	29
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	30	type TAttackParams = record
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	31	Time: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	32	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	33	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	34	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	35	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	36
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	37	function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	38	function TestSnowball(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	39	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	40	function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	41	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	42	function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	43	function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	44	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	45	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	46	function TestSniperRifle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	47	function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	48	function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): 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	49	function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	50	function TestKamikaze(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	51	function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	52	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	53	function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	54	function TestCake(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	55
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	56	type TAmmoTestProc = function (Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	57	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	58	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	59	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	60	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	61
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	62	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	63	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	64	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	65	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	66	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	67	(proc: @TestBazooka; flags: 0), // amBazooka
3080 b7fa8ad60e3b Engine: smxx parents: 3066 diff changeset	68	(proc: nil; flags: 0), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	69	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	70	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	71	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	72	(proc: nil; flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	73	(proc: nil; flags: 0), // amMine
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	74	(proc: @TestDesertEagle; flags: 0), // amDEagle
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	75	(proc: nil; flags: 0), // 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	76	(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	77	(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	78	(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	79	(proc: nil; flags: 0), // amParachute
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	80	(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	81	(proc: nil; flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	82	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	83	(proc: nil; flags: 0), // amGirder
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	84	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	85	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	87	(proc: @TestMortar; flags: 0), // amMortar
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	88	(proc: @TestKamikaze; flags: 0), // amKamikaze
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	89	(proc: @TestCake; flags: amtest_OnTurn or amtest_NoTarget), // amCake
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: nil; flags: 0), // amSeduction
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	91	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	92	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	93	(proc: nil; flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	94	(proc: nil; flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	95	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	96	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	97	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	98	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	99	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	100	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	101	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	102	(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	103	(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	104	(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	105	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	106	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	107	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	108	(proc: nil; flags: 0), // amPiano
3384 7eb4707d43f0 * added some comments sheepluva parents: 3382 diff changeset	109	(proc: @TestGrenade; flags: 0), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	110	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	111	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	112	(proc: @TestGrenade; flags: 0), // amSMine
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	113	(proc: @TestHammer; flags: amtest_NoTarget), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	114	(proc: nil; flags: 0), // amResurrector
4881 35e6269227b6 still in developement take on adding structures, working hiding of hogs and ejecting them later. Henek parents: 4580 diff changeset	115	(proc: nil; flags: 0), // amDrillStrike
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	116	(proc: nil; flags: 0), // amSnowball
4883 7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure Henek parents: 4881 diff changeset	117	(proc: nil; flags: 0), // amTardis
5024 1e332947147c Landgun, first pass. At sdw's request. nemo parents: 4976 diff changeset	118	(proc: nil; flags: 0), // amStructure
7007 0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	119	(proc: nil; flags: 0), // amLandGun
0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	120	(proc: nil; flags: 0) // amIceGun
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	121	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	122
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	123	const BadTurn = Low(LongInt) div 4;
369 2aed85310727 AI compiles, but doesn't work unc0rr parents: 351 diff changeset	124
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	125	implementation
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	126	uses uAIMisc, uVariables, uUtils, uGearsHandlers, uCollisions;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	127
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	128	function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	129	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	130	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	131	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	132
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	133	function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	134	var Vx, Vy, r, mX, mY: real;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	135	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	136	EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	137	valueResult: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	138	x, y, dX, dY: real;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	139	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	140	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	141	begin
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	142	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	143	mY:= hwFloat2Float(Me^.Y);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	144	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	145	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	146	ap.ExplR:= 0;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	147	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	148	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	149	rTime:= rTime + 300 + Level * 50 + random(300);
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	150	Vx:= - windSpeed * rTime * 0.5 + (Targ.X + AIrndSign(2) - mX) / rTime;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	151	Vy:= cGravityf * rTime * 0.5 - (Targ.Y - mY) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	152	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	153	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	154	begin
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	155	x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	156	y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	157	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	158	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	159	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	160	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	161	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	162	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	163	dX:= dX + windSpeed;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	164	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	165	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	166	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	167	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t <= 0);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	168
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	169	EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	170	EY:= trunc(y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	171	if Level = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	172	value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
6767 ccbf07b38a43 First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc) nemo parents: 6700 diff changeset	173	else value:= RateExplosion(Me, EX, EY, 101);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	174	if value = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	175	value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	176	if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	177	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	178	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	179	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	180	ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	181	ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	182	ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	183	valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	184	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	185	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	186	//until (value > 204800) or (rTime > 4250); not so useful since adding score to the drowning
13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	187	until rTime > 4250;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	188	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	189	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	190
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	191	function TestSnowball(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	192	var Vx, Vy, r: real;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	193	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	194	EX, EY: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	195	valueResult: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	196	x, y, dX, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	197	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	198	value: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	199
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	200	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	201	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	202	meY:= hwFloat2Float(Me^.Y);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	203	ap.Time:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	204	rTime:= 350;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	205	ap.ExplR:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	206	valueResult:= BadTurn;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	207	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	208	rTime:= rTime + 300 + Level * 50 + random(1000);
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	209	Vx:= - windSpeed * rTime * 0.5 + ((Targ.X + AIrndSign(2)) - meX) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	210	Vy:= cGravityf * rTime * 0.5 - (Targ.Y - meY) / rTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	211	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	212	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	213	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	214	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	215	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	216	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	217	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	218	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	219	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	220	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	221	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	222	dX:= dX + windSpeed;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	223	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	224	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	225	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	226	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t <= 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	227	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	228	EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	229
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	230	value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	231	if value = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	232	value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	233
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	234	if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	235	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	236	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	237	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	238	ap.ExplR:= 0;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	239	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	240	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	241	valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	242	end;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	243	end
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	244	until (rTime > 4250);
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	245	TestSnowball:= valueResult
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	246	end;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	247
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	248	function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	249	var Vx, Vy, r: real;
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	250	Score, EX, EY, valueResult: LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	251	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	252	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	253	t: LongInt;
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	254	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	255	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	256	meY:= hwFloat2Float(Me^.Y);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	257	valueResult:= BadTurn;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	258	TestTime:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	259	ap.ExplR:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	260	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	261	inc(TestTime, 300);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	262	Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	263	Vy:= cGravityf * (TestTime div 2) - Targ.Y - meY / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	264	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	265	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	266	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	267	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	268	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	269	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	270	t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	271	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	272	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	273	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	274	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	275	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	276	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	277	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 6))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	278	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	279	EY:= trunc(y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	280	if t < 50 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	281	Score:= RateExplosion(Me, EX, EY, 97) // average of 17 attempts, most good, but some failing spectacularly
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	282	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	283	Score:= BadTurn;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	284
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	285	if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	286	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	287	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	288	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	289	ap.Time:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	290	ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	291	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	292	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	293	valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	294	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	295	end
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	296	until (TestTime > 4250);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	297	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	298	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	299
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	300	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	301	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	302	var Vx, Vy, r: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	303	Score, EX, EY, valueResult: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	304	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	305	x, y, meX, meY, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	306	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	307	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	308	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	309	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	310	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	311	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	312	meY:= hwFloat2Float(Me^.Y);
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	313	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	314	inc(TestTime, 1000);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	315	Vx:= (Targ.X - meX) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	316	Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Y - meY) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	317	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	318	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	319	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	320	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	321	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	322	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	323	t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	324	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	325	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	326	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	327	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	328	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	329	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	330	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	331	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	332	EY:= trunc(y);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	333	if t < 50 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	334	if Level = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	335	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	336	else Score:= RateExplosion(Me, EX, EY, 101)
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	337	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	338	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	339
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	340	if valueResult < Score then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	341	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	342	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	343	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	344	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	345	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	346	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	347	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	348	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	349	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	350	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	351	//until (Score > 204800) or (TestTime > 4000);
13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	352	until TestTime > 4000;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	353	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	354	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	355
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	356	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	357	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	358	var Vx, Vy, r: real;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	359	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	360	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	361	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	362	t: LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	363	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	364	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	365	TestTime:= 500;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	366	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	367	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	368	meY:= hwFloat2Float(Me^.Y);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	369	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	370	inc(TestTime, 900);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	371	// Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	372	if meX<Targ.X then
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	373	Vx:= ((Targ.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	374	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	375	Vx:= ((Targ.X-10) - meX) / (TestTime + tDelta);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	376	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	377	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	378	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	379	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	380	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	381	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	382	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	383	t:= TestTime;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	384	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	385	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	386	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	387	dY:= dY + cGravityf;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	388	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	389	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	390	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	391	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	392	EY:= trunc(y);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	393	if t < 50 then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	394	Score:= RateExplosion(Me, EX, EY, 41)
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	395	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	396	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	397
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	398	if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	399	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	400	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	401	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	402	ap.Time:= TestTime div 1000 * 1000;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	403	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	404	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	405	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	406	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	407	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	408	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	409	until (TestTime = 4100);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	410	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	411	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	412
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	413	function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	414	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	415	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	416	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	417	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	418	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	419	t: LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	420	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	421	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	422	TestTime:= 500;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	423	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	424	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	425	meY:= hwFloat2Float(Me^.Y);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	426	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	427	inc(TestTime, 900);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	428	Vx:= (Targ.X - meX) / (TestTime + tDelta);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	429	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	430	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	431	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	432	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	433	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	434	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	435	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	436	t:= TestTime;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	437	repeat
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	438	x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	439	y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	440	dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	441	dec(t)
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	442	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	443	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 6))) or (t = 0);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	444
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	445	EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	446	EY:= trunc(y);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	447	if t < 50 then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	448	Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	449	else
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	450	Score:= BadTurn;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	451
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	452	if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	453	begin
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	454	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	455	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	456	ap.Time:= TestTime div 1000 * 1000;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	457	ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	458	ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	459	ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	460	valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	461	end;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	462	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	463	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	464	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	465	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	466
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	467
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	468	function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	469	var A, B, D, T: real;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	470	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	471	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	472	A:= sqr(cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	473	B:= - cGravityf * (TY - MY) - 1;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	474	C:= sqr(TY - MY) + sqr(TX - MX);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	475	D:= sqr(B) - A * C;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	476	if D >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	477	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	478	D:= sqrt(D) - B;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	479	if D >= 0 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	480	T:= sqrt(D * 2 / A)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	481	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	482	T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	483	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	484	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	485	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	486	Solve:= 0
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	487	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	488
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	489	function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	490	//const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	491	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	492	Score, EX, EY: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	493	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	494	x, y, dY, meX, meY: real;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	495	begin
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	496	TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	497	ap.ExplR:= 0;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	498	meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	499	meY:= hwFloat2Float(Me^.Y);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	500
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	501	if (Level > 2) then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	502	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	503
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	504	TestTime:= Solve(Targ.X, Targ.Y, trunc(meX), trunc(meY));
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	505
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	506	if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	507	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	508
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	509	Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	510	Vy:= cGravityf * (TestTime div 2) - (Targ.Y - meY) / TestTime;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	511
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	512	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	513	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	514	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	515
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	516	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	517	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	518	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	519	dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	520	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	521	EY:= trunc(y);
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	522	until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	523	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, EX, EY, 4))) or (EY > cWaterLine);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	524
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	525	if (EY < cWaterLine) and (dY >= 0) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	526	begin
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	527	Score:= RateExplosion(Me, EX, EY, 91);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	528	if (Score = 0) then
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	529	if (dY > 0.15) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	530	Score:= - abs(Targ.Y - EY) div 32
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	531	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	532	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	533	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	534	Score:= BadTurn
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	535	end
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	536	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	537	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	538
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	539	if BadTurn < Score then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	540	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	541	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	542	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	543	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	544	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	545	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	546	TestMortar:= Score
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	547	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	548	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	549
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	550	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	551	const
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	552	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	553	MAX_RANGE = 400;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	554	var Vx, Vy, x, y: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	555	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	556	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	557	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	558	TestShotgun:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	559	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	560	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	561	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	562	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	563	y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	564	range:= Metric(trunc(x), trunc(y), Targ.X, Targ.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	565	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	566	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	567
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	568	Vx:= (Targ.X - x) * 1 / 1024;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	569	Vy:= (Targ.Y - y) * 1 / 1024;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	570	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	571	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	572	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	573	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	574	rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	575	ry:= trunc(y);
7274 a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	576	if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate. nemo parents: 7212 diff changeset	577	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, 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	578	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	579	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	580	y:= y + vY * 8;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	581	valueResult:= RateShotgun(Me, vX, vY, rx, ry);
5642 0ce9e01bae56 Make AI aware of damage modifiers unc0rr parents: 5164 diff changeset	582
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	583	if valueResult = 0 then
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	584	valueResult:= - Metric(Targ.X, Targ.Y, rx, ry) div 64
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	585	else
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	586	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	587	// 27/20 is reuse bonus
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	588	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	589	end
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	590	until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	591	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	592	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	593	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	594	or (trunc(y) > LAND_HEIGHT);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	595
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	596	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	597	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	598
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	599	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	600	var Vx, Vy, x, y, t, dmgMod: real;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	601	d: Longword;
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	602	fallDmg, valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	603	begin
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	604	if Level > 3 then exit(BadTurn);
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	605	dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	606	Level:= Level; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	607	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	608	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	609	ap.Power:= 1;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	610
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	611	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	612	y:= hwFloat2Float(Me^.Y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	613
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	614	if Abs(trunc(x) - Targ.X) + Abs(trunc(y) - Targ.Y) < 40 then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	615	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	616	TestDesertEagle:= BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	617	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	618	end;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	619
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	620	t:= 2 / sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	621	Vx:= (Targ.X - x) * t;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	622	Vy:= (Targ.Y - y) * t;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	623	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	624	d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	625
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	626	repeat
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	627	x:= x + vX;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	628	y:= y + vY;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	629	if ((trunc(x) and LAND_WIDTH_MASK) = 0)and((trunc(y) and LAND_HEIGHT_MASK) = 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	630	and (Land[trunc(y), trunc(x)] <> 0) then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	631	inc(d);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	632	until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 5)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	633	or (x < 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	634	or (y < 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	635	or (trunc(x) > LAND_WIDTH)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	636	or (trunc(y) > LAND_HEIGHT)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	637	or (d > 50);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	638
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	639	if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 5 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	640	begin
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	641	fallDmg:= TraceShoveFall(Targ.X, Targ.Y, vX * 0.00125 * 20, vY * 0.00125 * 20);
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	642	if fallDmg < 0 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	643	valueResult:= 204800
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	644	else valueResult:= Max(0, (4 - d div 50) * trunc((7+fallDmg)dmgMod) 1024)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	645	end
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	646	else
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	647	valueResult:= BadTurn;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	648	TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	649	end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	650
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	651
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	652	function TestSniperRifle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	653	var Vx, Vy, x, y, t, dmg, dmgMod: real;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	654	d: Longword;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	655	fallDmg, valueResult: LongInt;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	656	begin
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	657	if Level > 3 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	658	dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	659	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	660	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	661	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	662	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	663	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	664	y:= hwFloat2Float(Me^.Y);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	665	if Abs(trunc(x) - Targ.X) + Abs(trunc(y) - Targ.Y) < 40 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	666	exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	667
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	668	dmg:= sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	669	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	670	dmg:= dmg * 0.025; // div 40
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	671	Vx:= (Targ.X - x) * t;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	672	Vy:= (Targ.Y - y) * t;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	673	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	674	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	675
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	676	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	677	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	678	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	679	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	680	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	681	inc(d);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	682	until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	683	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	684	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	685	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	686	or (trunc(y) > LAND_HEIGHT)
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	687	or (d > 23);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	688
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	689	if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4 then
6774 237b96f06aae Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time. nemo parents: 6772 diff changeset	690	begin
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	691	fallDmg:= TraceShoveFall(Targ.X, Targ.Y, vX * 0.00166 * dmg, vY * 0.00166 * dmg);
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	692	if fallDmg < 0 then
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	693	TestSniperRifle:= BadTurn
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	694	else
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	695	TestSniperRifle:= Max(0, trunc((dmg + fallDmg) * dmgMod) * 1024)
6774 237b96f06aae Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time. nemo parents: 6772 diff changeset	696	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	697	else
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	698	TestSniperRifle:= BadTurn
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	699	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	700
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	701
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	702	function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	703	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	704	x, y, trackFall: LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	705	dx, dy: real;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	706	begin
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	707	if Level < 3 then trackFall:= afTrackFall
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	708	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	709
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	710	ap.ExplR:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	711	ap.Time:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	712	ap.Power:= 1;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	713	x:= hwRound(Me^.X);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	714	y:= hwRound(Me^.Y);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	715
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	716	a:= cMaxAngle div 2;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	717	valueResult:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	718
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	719	while a >= 0 do
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	720	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	721	dx:= sin(a / cMaxAngle * pi) * 0.5;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	722	dy:= cos(a / cMaxAngle * pi) * 0.5;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	723
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	724	v1:= RateShove(Me, x - 10, y + 2
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	725	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	726	, -dx, -dy, trackFall);
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	727	v2:= RateShove(Me, x + 10, y + 2
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	728	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	729	, dx, -dy, trackFall);
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	730	if (v1 > valueResult) or (v2 > valueResult) then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	731	if (v2 > v1)
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	732	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	733	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	734	ap.Angle:= a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	735	valueResult:= v2
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	736	end
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	737	else
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	738	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	739	ap.Angle:= -a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	740	valueResult:= v1
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	741	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	742
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	743	a:= a - 15 - random(cMaxAngle div 16)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	744	end;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	745
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	746	if valueResult <= 0 then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	747	valueResult:= BadTurn;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	748
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	749	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	750	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	751
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	752	function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	753	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	754	x, y, trackFall: LongInt;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	755	begin
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	756	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	757	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	758
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	759	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	760	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	761	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	762	x:= hwRound(Me^.X);
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	763	y:= hwRound(Me^.Y) + 4;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	764
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	765	v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	766	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	767	begin
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	768	v1:= v1 + RateShove(Me, x - 5, y - 10 * i
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	769	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	770	, -0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	771	end;
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	772	v1:= v1 + RateShove(Me, x - 5, y - 90
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	773	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	774	, -0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	775
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	776
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	777	// now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	778	v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	779	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	780	begin
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	781	v2:= v2 + RateShove(Me, x + 5, y - 10 * i
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	782	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	783	, 0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	784	end;
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	785	v2:= v2 + RateShove(Me, x + 5, y - 90
48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	786	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	787	, 0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	788
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	789	if (v2 > v1)
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	790	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	791	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	792	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	793	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	794	end
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	795	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	796	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	797	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	798	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	799	end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	800
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	801	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	802	valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	803
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	804	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	805	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	806
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	807
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	808	function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	809	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	810	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	811	begin
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	812	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	813	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	814
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	815	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	816	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	817	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	818	x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	819	y:= hwRound(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	820
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	821	// check left direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	822	{first RateShove checks farthermost of two whip's AmmoShove attacks
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	823	to encourage distant attacks (damaged hog is excluded from view of second
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	824	RateShove call)}
7433 c7fff3e61d49 - Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases) unc0rr parents: 7427 diff changeset	825	v1:= RateShove(Me, x - 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	826	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	827	, -1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	828	v1:= v1 +
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	829	RateShove(Me, x - 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	830	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	831	, -1, -0.8, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	832	// now try opposite direction
7433 c7fff3e61d49 - Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases) unc0rr parents: 7427 diff changeset	833	v2:= RateShove(Me, x + 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	834	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	835	, 1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	836	v2:= v2 +
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	837	RateShove(Me, x + 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	838	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	839	, 1, -0.8, trackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	840
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	841	if (v2 > v1)
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	842	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	843	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	844	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	845	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	846	end
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	847	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	848	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	849	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	850	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	851	end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	852
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	853	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	854	valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	855	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	856	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	857
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	858	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	859	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	860
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	861	function TestKamikaze(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	862	const step = 8;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	863	var valueResult, i, v, tx: LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	864	trackFall: LongInt;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	865	t, d, x, y, dx, dy, cx: real;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	866	begin
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	867	ap.ExplR:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	868	ap.Time:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	869	ap.Power:= 1;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	870
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	871	if Level = 1 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	872	trackFall:= afTrackFall
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	873	else if Level = 2 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	874	trackFall:= 0
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	875	else
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	876	exit(BadTurn);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	877
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	878	valueResult:= 0;
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	879	v:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	880
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	881	x:= hwFloat2Float(Me^.X);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	882	y:= hwFloat2Float(Me^.Y);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	883	d:= sqrt(sqr(Targ.X - x) + sqr(Targ.Y - y));
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	884	if d < 10 then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	885	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	886	dx:= 0;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	887	dy:= 8;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	888	ap.Angle:= 2048
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	889	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	890	else
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	891	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	892	t:= step / d;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	893	dx:= (Targ.X - x) * t;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	894	dy:= (Targ.Y - y) * t;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	895
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	896	ap.Angle:= DxDy2AttackAnglef(dx, -dy)
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	897	end;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	898
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	899	if dx >= 0 then cx:= 0.45 else cx:= -0.45;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	900
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	901	for i:= 0 to 512 div step - 2 do
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	902	begin
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	903	valueResult:= valueResult +
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	904	RateShove(Me, trunc(x), trunc(y)
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	905	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	906	, cx, -0.9, trackFall or afSetSkip);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	907
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	908	x:= x + dx;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	909	y:= y + dy;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	910	end;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	911	if dx = 0 then
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	912	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	913	x:= hwFloat2Float(Me^.X);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	914	y:= hwFloat2Float(Me^.Y);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	915	tx:= trunc(x);
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	916	v:= RateShove(Me, tx, trunc(y)
f3a13da9fa4e oops nemo parents: 7474 diff changeset	917	, 30, 30, 25
f3a13da9fa4e oops nemo parents: 7474 diff changeset	918	, -cx, -0.9, trackFall);
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	919	for i:= 1 to 512 div step - 2 do
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	920	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	921	y:= y + dy;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	922	v:= v +
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	923	RateShove(Me, tx, trunc(y)
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	924	, 30, 30, 25
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	925	, -cx, -0.9, trackFall or afSetSkip);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	926	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	927	end;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	928	if v > valueResult then
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	929	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	930	ap.Angle:= -2048;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	931	valueResult:= v
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	932	end;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	933
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	934	v:= RateShove(Me, trunc(x), trunc(y)
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	935	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	936	, cx, -0.9, trackFall);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	937	valueResult:= valueResult + v - KillScore * friendlyfactor div 100 * 1024;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	938
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	939	if v < 65536 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	940	inc(valueResult, RateExplosion(Me, trunc(x), trunc(y), 30));
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	941
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	942	TestKamikaze:= valueResult;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	943	end;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	944
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	945	function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	946	var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	947	begin
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	948	Level:= Level; // avoid compiler hint
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	949	ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	950	ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	951	ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	952	ap.Angle:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	953
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	954	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	955	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	956	rate:= BadTurn;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	957	TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	958	end;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	959
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	960	function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	961	const cShift = 4;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	962	var bombsSpeed, X, Y, dY: real;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	963	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	964	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	965	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	966	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	967	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	968	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	969	ap.Time:= 0;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	970	if (Level > 3) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	971	exit(BadTurn);
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	972
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	973	ap.Angle:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	974	ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	975	ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	976
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	977	bombsSpeed:= hwFloat2Float(cBombsSpeed);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	978	X:= Targ.X - 135 - cShift; // hh center - cShift
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	979	X:= X - bombsSpeed * sqrt(((Targ.Y + 128) * 2) / cGravityf);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	980	Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	981	dY:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	982
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	983	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	984	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	985	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	986	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	987	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	988	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	989
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	990	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	991	X:= X + bombsSpeed;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	992	Y:= Y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	993	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	994	fexit:= true;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	995
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	996	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	997	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	998	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	999	fexit:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1000	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	1001	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1002	b[i]:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1003	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	1004	// 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	1005	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1006	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1007	until fexit or (Y > cWaterLine);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1008
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1009	for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1010	t:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1011	ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1012
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1013	for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1014	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1015	dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1016	inc(t, dmg[i + 6]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1017	if t > valueResult then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1018	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1019	valueResult:= t;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1020	ap.AttackPutX:= Targ.X - 30 - cShift + i * 30
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1021	end
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1022	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1023
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1024	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	1025	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1026	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1027	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1028
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1029
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1030	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1031	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1032	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1033	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1034	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1035	TestTeleport := BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1036	exit(BadTurn);
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1037	Level:= Level; // avoid compiler hint
6888 32a54322d262 Get rid of TGearsType to simplify pas2c unc0rr parents: 6879 diff changeset	1038	//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	1039	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	1040	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1041	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	1042	begin
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	1043	maxTop := Targ.Y - cHHRadius * 2;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1044
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1045	while not TestColl(Targ.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	1046	dec(maxTop, cHHRadius*2);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1047	if not TestColl(Targ.X, maxTop + cHHRadius, cHHRadius) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1048	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1049	ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1050	ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1051	TestTeleport := Targ.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	1052	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1053	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1054	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1055	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1056	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1057	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	1058	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1059	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1060	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	1061	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	1062	or (failNum = bonuses.Count*2);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1063
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1064	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	1065	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1066	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1067	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1068	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	1069	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1070	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1071	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1072
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1073
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	1074	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	1075	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	1076	v: LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1077	begin
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	1078	while (not TestColl(hwRound(Gear^.X), hwRound(Gear^.Y), 6)) and (Gear^.Y.Round < LAND_HEIGHT) 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	1079	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	1080
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	1081	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	1082	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	1083	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	1084	v:= RateExplosion(Me, hwRound(Gear^.X), hwRound(Gear^.Y), cakeDmg * 2, afTrackFall);
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	1085	if v > ap.Power then
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	1086	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	1087	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	1088	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	1089	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	1090	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	1091	end;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1092	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1093
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1094	function TestCake(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1095	var valueResult, v1, v2: LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1096	x, y, trackFall: LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1097	cake: TGear;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1098	begin
7501 1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1099	if (Level > 2) then
1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1100	exit(BadTurn);
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1101	ap.ExplR:= 0;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1102	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	1103	ap.Power:= BadTurn; // use it as max score value in checkCakeWalk
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1104
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	1105	FillChar(cake, sizeof(cake), 0);
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1106	cake.Radius:= 7;
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	1107	cake.CollisionMask:= $FF7F;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1108
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1109	// check left direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1110	cake.Angle:= 3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1111	cake.dX.isNegative:= true;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1112	cake.X:= Me^.X - _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1113	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	1114	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	1115	v1:= ap.Power;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1116
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1117	// now try opposite direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1118	cake.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1119	cake.dX.isNegative:= false;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1120	cake.X:= Me^.X + _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1121	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	1122	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	1123	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	1124
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	1125	ap.Power:= 1;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1126
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1127	if (v2 > v1) then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1128	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1129	ap.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1130	valueResult:= v2
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1131	end
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1132	else
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1133	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1134	ap.Angle:= -1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1135	valueResult:= v1
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1136	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1137
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1138	if valueResult <= 0 then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1139	valueResult:= BadTurn;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1140
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1141	TestCake:= valueResult;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1142	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1143
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	1144	end.

author	nemo
	Sun, 26 Aug 2012 20:20:16 -0400
changeset 7610	682e21112867
parent 7501	1763dc3bc9b7
child 7620	fa3bc79dc0b8
permissions	-rw-r--r--