sheepy-clone: hedgewars/uAIAmmoTests.pas@af64b509725c (annotated)

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

author	Wolfgang Steffens <WolfgangSteff@gmail.com>
	Mon, 25 Jun 2012 15:46:08 +0200
changeset 7297	af64b509725c
parent 7274	a07777b818f1
child 7348	2a69f2ed9273
permissions	-rw-r--r--