hedgewars-draft: hedgewars/uAIAmmoTests.pas@580cd247511e (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;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	46	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	47	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	48	function TestWhip(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	49	function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	50	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	51	function TestHammer(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	52
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	53	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	54	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	55	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	56	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	57	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	58
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	59	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	60	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	61	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	62	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	63	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	64	(proc: @TestBazooka; flags: 0), // amBazooka
3080 b7fa8ad60e3b Engine: smxx parents: 3066 diff changeset	65	(proc: nil; flags: 0), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	66	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	67	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	68	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	69	(proc: nil; flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	70	(proc: nil; flags: 0), // amMine
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	71	(proc: @TestDesertEagle; flags: 0), // amDEagle
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	72	(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	73	(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	74	(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	75	(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	76	(proc: nil; flags: 0), // amParachute
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	77	(proc: @TestAirAttack; flags: amtest_OnTurn), // amAirAttack
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	78	(proc: nil; flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	79	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	80	(proc: nil; flags: 0), // amGirder
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	81	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	82	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	83	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	84	(proc: @TestMortar; flags: 0), // amMortar
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	85	(proc: nil; flags: 0), // amKamikaze
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amCake
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	87	(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	88	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	89	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: nil; flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	91	(proc: nil; flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	92	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	93	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	94	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	95	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	96	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	97	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	98	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	99	(proc: nil; flags: 0), // amVampiric
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	100	(proc: nil; flags: 0), // amSniperRifle
3342 b4f01613dcd7 Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here. nemo parents: 3236 diff changeset	101	(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	102	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	103	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	104	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	105	(proc: nil; flags: 0), // amPiano
3384 7eb4707d43f0 * added some comments sheepluva parents: 3382 diff changeset	106	(proc: @TestGrenade; flags: 0), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	107	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	108	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	109	(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	110	(proc: @TestHammer; flags: amtest_NoTarget), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	111	(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	112	(proc: nil; flags: 0), // amDrillStrike
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	113	(proc: nil; flags: 0), // amSnowball
4883 7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure Henek parents: 4881 diff changeset	114	(proc: nil; flags: 0), // amTardis
5024 1e332947147c Landgun, first pass. At sdw's request. nemo parents: 4976 diff changeset	115	(proc: nil; flags: 0), // amStructure
7007 0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	116	(proc: nil; flags: 0), // amLandGun
0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	117	(proc: nil; flags: 0) // amIceGun
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	118	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	119
439 c336ed82e76d Fix bugs: unc0rr parents: 438 diff changeset	120	const BadTurn = Low(LongInt) div 4;
369 2aed85310727 AI compiles, but doesn't work unc0rr parents: 351 diff changeset	121
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	122	implementation
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	123	uses uAIMisc, uVariables, uUtils;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	124
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	125	function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	126	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	127	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	128	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	129
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	130	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	131	var Vx, Vy, r, mX, mY: real;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	132	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	133	EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	134	valueResult: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	135	x, y, dX, dY: real;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	136	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	137	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	138	begin
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	139	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	140	mY:= hwFloat2Float(Me^.Y);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	141	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	142	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	143	ap.ExplR:= 0;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	144	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	145	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	146	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	147	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	148	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	149	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	150	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	151	begin
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	152	x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	153	y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	154	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	155	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	156	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	157	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	158	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	159	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	160	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	161	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	162	dec(t)
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	163	until 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	164
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	165	EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	166	EY:= trunc(y);
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	167	if Me^.Hedgehog^.BotLevel = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	168	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	169	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	170	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	171	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	172	if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	173	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	174	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	175	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	176	ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	177	ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	178	ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	179	valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	180	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	181	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	182	//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	183	until rTime > 4250;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	184	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	185	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	186
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	187	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	188	var Vx, Vy, r: real;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	189	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	190	EX, EY: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	191	valueResult: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	192	x, y, dX, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	193	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	194	value: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	195
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	196	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	197	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	198	meY:= hwFloat2Float(Me^.Y);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	199	ap.Time:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	200	rTime:= 350;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	201	ap.ExplR:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	202	valueResult:= BadTurn;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	203	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	204	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	205	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	206	Vy:= cGravityf * rTime * 0.5 - (Targ.Y - meY) / rTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	207	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	208	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	209	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	210	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	211	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	212	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	213	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	214	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	215	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	216	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	217	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	218	dX:= dX + windSpeed;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	219	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	220	dec(t)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	221	until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t <= 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	222	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	223	EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	224
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	225	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	226	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	227	value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	228
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	229	if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	230	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	231	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	232	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	233	ap.ExplR:= 0;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	234	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	235	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	236	valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	237	end;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	238	end
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	239	until (rTime > 4250);
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	240	TestSnowball:= valueResult
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	241	end;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	242
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	243	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	244	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	245	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	246	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	247	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	248	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	249	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	250	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	251	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	252	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	253	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	254	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	255	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	256	inc(TestTime, 300);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	257	Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	258	Vy:= cGravityf * (TestTime div 2) - Targ.Y - meY / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	259	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	260	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	261	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	262	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	263	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	264	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	265	t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	266	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	267	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	268	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	269	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	270	dec(t)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	271	until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	272	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	273	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	274	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	275	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	276	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	277	Score:= BadTurn;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	278
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	279	if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	280	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	281	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	282	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	283	ap.Time:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	284	ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	285	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	286	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	287	valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	288	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	289	end
3022 94afd5fc5738 Adjust increment since there is no timer nemo parents: 3018 diff changeset	290	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	291	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	292	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	293
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	294	function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	295	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	296	var Vx, Vy, r: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	297	Score, EX, EY, valueResult: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	298	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	299	x, y, meX, meY, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	300	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	301	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	302	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	303	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	304	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	305	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	306	meY:= hwFloat2Float(Me^.Y);
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	307	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	308	inc(TestTime, 1000);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	309	Vx:= (Targ.X - meX) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	310	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	311	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	312	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	313	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	314	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	315	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	316	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	317	t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	318	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	319	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	320	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	321	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	322	dec(t)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	323	until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	324	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	325	EY:= trunc(y);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	326	if t < 50 then
6769 44ad49a3a126 Add drowning to grenade too, try some little optimisations nemo parents: 6767 diff changeset	327	if Me^.Hedgehog^.BotLevel = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	328	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	329	else Score:= RateExplosion(Me, EX, EY, 101)
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	330	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	331	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	332
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	333	if valueResult < Score then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	334	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	335	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	336	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	337	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	338	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	339	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	340	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	341	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	342	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	343	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	344	//until (Score > 204800) or (TestTime > 4000);
13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	345	until TestTime > 4000;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	346	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	347	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	348
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	349	function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	350	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	351	var Vx, Vy, r: real;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	352	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	353	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	354	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	355	t: LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	356	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	357	valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	358	TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	359	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	360	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	361	meY:= hwFloat2Float(Me^.Y);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	362	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	363	inc(TestTime, 1000);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	364	// 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	365	if meX<Targ.X then
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	366	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	367	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	368	Vx:= ((Targ.X-10) - meX) / (TestTime + tDelta);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	369	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	370	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	371	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	372	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	373	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	374	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	375	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	376	t:= TestTime;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	377	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	378	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	379	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	380	dY:= dY + cGravityf;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	381	dec(t)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	382	until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	383	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	384	EY:= trunc(y);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	385	if t < 50 then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	386	Score:= RateExplosion(Me, EX, EY, 41)
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	387	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	388	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	389
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	390	if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	391	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	392	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	393	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	394	ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	395	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	396	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	397	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	398	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	399	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	400	end
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	401	until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	402	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	403	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	404
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	405	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	406	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	407	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	408	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	409	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	410	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	411	t: LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	412	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	413	valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	414	TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	415	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	416	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	417	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	418	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	419	inc(TestTime, 1000);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	420	Vx:= (Targ.X - meX) / (TestTime + tDelta);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	421	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	422	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	423	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	424	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	425	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	426	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	427	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	428	t:= TestTime;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	429	repeat
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	430	x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	431	y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	432	dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	433	dec(t)
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	434	until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	435
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	436	EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	437	EY:= trunc(y);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	438	if t < 50 then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	439	Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	440	else
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	441	Score:= BadTurn;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	442
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	443	if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	444	begin
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	445	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	446	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	447	ap.Time:= TestTime;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	448	ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	449	ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	450	ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	451	valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	452	end;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	453	end
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	454	until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	455	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	456	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	457
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	458
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	459	function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	460	var A, B, D, T: real;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	461	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	462	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	463	A:= sqr(cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	464	B:= - cGravityf * (TY - MY) - 1;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	465	C:= sqr(TY - MY) + sqr(TX - MX);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	466	D:= sqr(B) - A * C;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	467	if D >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	468	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	469	D:= sqrt(D) - B;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	470	if D >= 0 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	471	T:= sqrt(D * 2 / A)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	472	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	473	T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	474	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	475	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	476	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	477	Solve:= 0
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	478	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	479
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	480	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	481	//const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	482	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	483	Score, EX, EY: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	484	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	485	x, y, dY, meX, meY: real;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	486	begin
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	487	TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	488	ap.ExplR:= 0;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	489	meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	490	meY:= hwFloat2Float(Me^.Y);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	491
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	492	if (Level > 2) then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	493	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	494
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	495	TestTime:= Solve(Targ.X, Targ.Y, trunc(meX), trunc(meY));
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	496
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	497	if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	498	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	499
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	500	Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	501	Vy:= cGravityf * (TestTime div 2) - (Targ.Y - meY) / TestTime;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	502
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	503	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	504	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	505	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	506
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	507	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	508	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	509	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	510	dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	511	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	512	EY:= trunc(y);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	513	until TestCollExcludingMe(Me, EX, EY, 5) or (EY > cWaterLine);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	514
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	515	if (EY < cWaterLine) and (dY >= 0) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	516	begin
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	517	Score:= RateExplosion(Me, EX, EY, 91);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	518	if (Score = 0) then
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	519	if (dY > 0.15) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	520	Score:= - abs(Targ.Y - EY) div 32
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	521	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	522	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	523	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	524	Score:= BadTurn
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	525	end
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	526	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	527	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	528
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	529	if BadTurn < Score then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	530	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	531	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	532	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	533	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	534	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	535	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	536	TestMortar:= Score
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	537	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	538	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	539
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	540	function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	541	const
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	542	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	543	MAX_RANGE = 400;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	544	var Vx, Vy, x, y: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	545	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	546	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	547	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	548	TestShotgun:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	549	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	550	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	551	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	552	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	553	y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	554	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	555	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	556	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	557
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	558	Vx:= (Targ.X - x) * 1 / 1024;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	559	Vy:= (Targ.Y - y) * 1 / 1024;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	560	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	561	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	562	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	563	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	564	rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	565	ry:= 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	566	if 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	567	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	568	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	569	y:= y + vY * 8;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	570	valueResult:= RateShotgun(Me, vX, vY, rx, ry);
5642 0ce9e01bae56 Make AI aware of damage modifiers unc0rr parents: 5164 diff changeset	571
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	572	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	573	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	574	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	575	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	576	// 27/20 is reuse bonus
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	577	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	578	end
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	579	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	580	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	581	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	582	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	583	or (trunc(y) > LAND_HEIGHT);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	584
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	585	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	586	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	587
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	588	function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	589	var Vx, Vy, x, y, t, dmgMod: real;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	590	d: Longword;
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	591	fallDmg, valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	592	begin
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	593	dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	594	Level:= Level; // avoid compiler hint
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	595	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	596	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	597	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	598	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	599	y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	600	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	601	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	602	TestDesertEagle:= BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	603	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	604	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	605	t:= 0.5 / sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	606	Vx:= (Targ.X - x) * t;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	607	Vy:= (Targ.Y - y) * t;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	608	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	609	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	610
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	611	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	612	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	613	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	614	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	615	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	616	inc(d);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	617	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	618	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	619	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	620	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	621	or (trunc(y) > LAND_HEIGHT)
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	622	or (d > 200);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	623
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	624	if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 3 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	625	begin
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	626	fallDmg:= TraceShoveFall(Me, Targ.X, Targ.Y, vX * 0.005 * 20, vY * 0.005 * 20);
8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	627	if fallDmg < 0 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	628	valueResult:= 204800
6783 8d9160b85bdb Add fall damage nemo parents: 6782 diff changeset	629	else valueResult:= Max(0, (4 - d div 50) * trunc((7+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	630	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	631	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	632	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	633	TestDesertEagle:= valueResult
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	634	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	635
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	636	function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	637	var valueResult: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	638	x, y: real;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	639	begin
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	640	Level:= Level; // avoid compiler hint
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	641	TestBaseballBat:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	642	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	643	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	644	y:= hwFloat2Float(Me^.Y);
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	645	if (Level > 2) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	646	exit(BadTurn);
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	647
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	648	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	649	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	650	if (Targ.X) - 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	651	ap.Angle:= cMaxAngle div 4
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	652	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	653	ap.Angle:= - cMaxAngle div 4;
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	654
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	655	valueResult:= RateShove(Me, trunc(x) + LongWord(10hwSignf(Targ.X - x)), trunc(y), 15, 30, 115, hwSign(Me^.dX)0.353, -0.353, afTrackFall);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	656	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	657	valueResult:= BadTurn
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	658	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	659	inc(valueResult);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	660	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	661	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	662
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	663	function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	664	var val1, val2, i, t: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	665	x, y: real;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	666	begin
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	667	Level:= Level; // avoid compiler hint
7134 beb16926ae5c Some improvements to pas2c unc0rr parents: 7132 diff changeset	668	TestFirePunch:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	669	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	670	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	671	ap.Power:= 1;
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	672	ap.Angle:= hwSign(Me^.dX);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	673	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	674	y:= hwFloat2Float(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	675	{
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	676	// this block is for digging with firepunch when blocked close to walls (notice TestColl check)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	677	if (Abs(trunc(x) - Targ.X) > 25)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	678	or (Abs(trunc(y) + 50 - Targ.Y) > 50) then
3677 7d917b587547 Engine: smaxx parents: 3476 diff changeset	679	begin
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	680	if TestColl(trunc(x), trunc(y) - 16, 6) and
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	681	(RateShove(Me, trunc(x) + LongWord(10 * hwSign(Me^.dX)),
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	682	trunc(y) - 40, 30, 30, 40, hwSign(Me^.dX)*0.45, -0.9, 1) >= 0) then
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	683	val1:= Succ(BadTurn)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	684	else
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	685	val1:= BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	686	exit(val1);
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	687	end;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	688	}
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	689	// and this is actual try to attack
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	690	val1:= 0;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	691	for i:= 0 to 4 do
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	692	begin
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	693	t:= RateShove(Me, trunc(x) + 10 * hwSignf(Targ.X - x), trunc(y) - 20 * i - 5, 10, 30, 40, hwSign(Me^.dX)*0.45, -0.9, afTrackFall);
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	694	if (val1 < 0) or (t < 0) then val1:= BadTurn
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	695	else if t > 0 then val1:= t;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	696	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	697
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	698	val2:= 0;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	699	for i:= 0 to 4 do
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	700	begin
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	701	t:= RateShove(Me, trunc(x) + 10 * hwSignf(Targ.X - x), trunc(y) - 20 * i - 5, 10, 30, 40, -hwSign(Me^.dX)*0.45, -0.9, afTrackFall);
6782 33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	702	if (val2 < 0) or (t < 0) then val2:= BadTurn
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	703	else if t > 0 then val2:= t;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	704	end;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	705	if (val1 > val2) and (val1 > 0) then
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	706	TestFirePunch:= val1
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	707	else if (val2 > val1) and (val2 > 0) then
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	708	begin
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	709	ap.Angle:= -hwSign(Me^.dX);
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	710	TestFirePunch:= val2
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch. nemo parents: 6775 diff changeset	711	end
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	712	else TestFirePunch:= BadTurn;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	713	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	714
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	715
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	716	function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	717	var valueResult, v1, v2: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	718	x, y: real;
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	719	begin
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	720	Level:= Level; // avoid compiler hint
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	721	ap.ExplR:= 0;
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	722	ap.Time:= 0;
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	723	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	724	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	725	y:= hwFloat2Float(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	726
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	727	// check left direction
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	728	{first RateShove checks fartherest of two whip's AmmoShove attacks
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	729	to encourage distant attacks (damaged hog is excluded from view of second
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	730	RateShove call)}
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	731	v1:= RateShove(Me, trunc(x) - 15, trunc(y)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	732	, 30, 30, 40
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	733	, -1, -0.8, afTrackFall or afSetSkip);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	734	v1:= v1 +
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	735	RateShove(Me, trunc(x), trunc(y)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	736	, 30, 30, 40
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	737	, -1, -0.8, afTrackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	738	// now try opposite direction
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	739	v2:= RateShove(Me, trunc(x) + 15, trunc(y)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	740	, 30, 30, 40
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	741	, 1, -0.8, afTrackFall or afSetSkip);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	742	v2:= v2 +
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	743	RateShove(Me, trunc(x), trunc(y)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	744	, 30, 30, 40
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	745	, 1, -0.8, afTrackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	746
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	747	if (v2 > v1)
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	748	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
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	749	begin
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	750	ap.Angle:= 1;
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	751	valueResult:= v2
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	752	end
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	753	else
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	754	begin
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	755	ap.Angle:= -1;
56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	756	valueResult:= v1
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	757	end;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	758
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	759	if valueResult <= 0 then
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	760	valueResult:= BadTurn
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	761	else
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	762	inc(valueResult);
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	763
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	764	TestWhip:= valueResult;
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	765	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	766
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	767	function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	768	var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	769	begin
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	770	Level:= Level; // avoid compiler hint
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	771	ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	772	ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	773	ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	774	ap.Angle:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	775
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	776	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	777	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	778	rate:= BadTurn;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	779	TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	780	end;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	781
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	782	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	783	const cShift = 4;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	784	var bombsSpeed, X, Y, dY: real;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	785	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	786	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	787	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	788	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	789	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	790	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	791	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	792	if (Level > 3) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	793	exit(BadTurn);
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	794
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	795	ap.Angle:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	796	ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	797	ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	798
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	799	bombsSpeed:= hwFloat2Float(cBombsSpeed);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	800	X:= Targ.X - 135 - cShift; // hh center - cShift
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	801	X:= X - bombsSpeed * sqrt(((Targ.Y + 128) * 2) / cGravityf);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	802	Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	803	dY:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	804
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	805	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	806	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	807	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	808	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	809	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	810	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	811
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	812	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	813	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	814	Y:= Y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	815	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	816	fexit:= true;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	817
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	818	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	819	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	820	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	821	fexit:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	822	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	823	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	824	b[i]:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	825	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	826	// 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	827	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	828	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	829	until fexit or (Y > cWaterLine);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	830
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	831	for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	832	t:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	833	ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	834
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	835	for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	836	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	837	dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	838	inc(t, dmg[i + 6]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	839	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	840	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	841	valueResult:= t;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	842	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	843	end
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	844	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	845
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	846	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	847	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	848	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	849	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	850
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	851
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	852	function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	853	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	854	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	855	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	856	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	857	TestTeleport := BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	858	exit(BadTurn);
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	859	Level:= Level; // avoid compiler hint
6888 32a54322d262 Get rid of TGearsType to simplify pas2c unc0rr parents: 6879 diff changeset	860	//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	861	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	862	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	863	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	864	begin
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	865	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	866
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	867	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	868	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	869	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	870	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	871	ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	872	ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	873	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	874	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	875	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	876	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	877	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	878	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	879	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	880	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	881	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	882	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	883	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	884	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	885
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	886	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	887	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	888	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	889	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	890	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	891	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	892	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	893	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	894
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	895	end.

author	Wolfgang Steffens <WolfgangSteff@gmail.com>
	Tue, 05 Jun 2012 22:37:36 +0200
changeset 7188	580cd247511e
parent 7178	c61cfc9eb29d
child 7197	5a9775b97c7e
permissions	-rw-r--r--