hedgewars-draft: hedgewars/uAIAmmoTests.pas@ca11d122f54e (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
9998 736015b847e3 update copyright to 2014 sheepluva parents: 9844 diff changeset	3	* Copyright (c) 2004-2014 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
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	23	uses uConsts, uFloat, uTypes, uAIMisc;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	24	const
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	25	amtest_Rare = $00000001; // check only several positions
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	26	amtest_NoTarget = $00000002; // each pos, but no targetting
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	27	amtest_MultipleAttacks = $00000004; // test could result in multiple attacks, set AttacksNum
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	28
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	29	var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	30
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	31	type TAttackParams = record
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	32	Time, AttacksNum: Longword;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	33	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	34	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	35	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	36	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	37
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	38	function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	39	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	40	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	41	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	42	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	43	function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	44	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	45	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	46	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	47	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	48	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	49	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	50	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	51	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	52	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	53	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	54	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	55	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	56	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	57	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	58
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	59	type TAmmoTestProc = function (Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	60	TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	61	proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	62	flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	63	end;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	64
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	65	const AmmoTests: array[TAmmoType] of TAmmoTest =
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	66	(
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	67	(proc: nil; flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	68	(proc: @TestGrenade; flags: 0), // amGrenade
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	69	(proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	70	(proc: @TestBazooka; flags: 0), // amBazooka
3080 b7fa8ad60e3b Engine: smxx parents: 3066 diff changeset	71	(proc: nil; flags: 0), // amBee
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	72	(proc: @TestShotgun; flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	73	(proc: nil; flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	74	(proc: nil; flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	75	(proc: nil; flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	76	(proc: nil; flags: 0), // amMine
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	77	(proc: @TestDesertEagle; flags: amtest_MultipleAttacks), // amDEagle
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	78	(proc: @TestDynamite; flags: amtest_NoTarget), // amDynamite
7178 c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position unc0rr parents: 7161 diff changeset	79	(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	80	(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	81	(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	82	(proc: nil; flags: 0), // amParachute
7789 838d2e06c377 Check cake and air attack again if walked far from initial position (not tested) unc0rr parents: 7760 diff changeset	83	(proc: @TestAirAttack; flags: amtest_Rare), // amAirAttack
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	84	(proc: nil; flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	85	(proc: nil; flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	86	(proc: nil; flags: 0), // amGirder
3739 97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	87	(proc: nil; flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport koda parents: 3717 diff changeset	88	//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	89	(proc: nil; flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	90	(proc: @TestMortar; flags: 0), // amMortar
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	91	(proc: @TestKamikaze; flags: 0), // amKamikaze
7789 838d2e06c377 Check cake and air attack again if walked far from initial position (not tested) unc0rr parents: 7760 diff changeset	92	(proc: @TestCake; flags: amtest_Rare or amtest_NoTarget), // amCake
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	93	(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	94	(proc: @TestWatermelon; flags: 0), // amWatermelon
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	95	(proc: nil; flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	96	(proc: nil; flags: 0), // amNapalm
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	97	(proc: @TestDrillRocket; flags: 0), // amDrill
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	98	(proc: nil; flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	99	(proc: nil; flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	100	(proc: nil; flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	101	(proc: nil; flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	102	(proc: nil; flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	103	(proc: nil; flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	104	(proc: nil; flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	105	(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	106	(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	107	(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	108	(proc: @TestMolotov; flags: 0), // amMolotov
3350 5cd02aafc612 Engine: smxx parents: 3342 diff changeset	109	(proc: nil; flags: 0), // amBirdy
5cd02aafc612 Engine: smxx parents: 3342 diff changeset	110	(proc: nil; flags: 0), // amPortalGun
3382 633046fa040c Gas grenade: mbait parents: 3372 diff changeset	111	(proc: nil; flags: 0), // amPiano
3384 7eb4707d43f0 * added some comments sheepluva parents: 3382 diff changeset	112	(proc: @TestGrenade; flags: 0), // amGasBomb
3476 1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works. nemo parents: 3439 diff changeset	113	(proc: @TestShotgun; flags: 0), // amSineGun
3710 411f5c2b5292 Engine: smaxx parents: 3697 diff changeset	114	(proc: nil; flags: 0), // amFlamethrower
3717 d88719b0f0dc Engine: smaxx parents: 3710 diff changeset	115	(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	116	(proc: @TestHammer; flags: amtest_NoTarget), // amHammer
4246 e5cb885492df drillstrike! might require the drill patch to improve behavior koda parents: 4226 diff changeset	117	(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	118	(proc: nil; flags: 0), // amDrillStrike
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	119	(proc: nil; flags: 0), // amSnowball
4883 7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure Henek parents: 4881 diff changeset	120	(proc: nil; flags: 0), // amTardis
8161 0b8beacff8a5 GCI2012: Remove Structure Weapon Code deepdog parents: 8033 diff changeset	121	//(proc: nil; flags: 0), // amStructure
7007 0ccdff4ae8e9 Initial stub for freezer nemo parents: 6992 diff changeset	122	(proc: nil; flags: 0), // amLandGun
7730 2013733f9ca9 A bit more on the knife. Also add missing files to CMakeLists nemo parents: 7721 diff changeset	123	(proc: nil; flags: 0), // amIceGun
9768 08799c901a42 Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config. nemo parents: 9722 diff changeset	124	(proc: nil; flags: 0), // amKnife
08799c901a42 Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config. nemo parents: 9722 diff changeset	125	(proc: nil; flags: 0) // amGirder
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	126	);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	127
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	128	implementation
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	129	uses uVariables, uUtils, uGearsHandlers;
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	130
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	131	function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	132	begin
370 c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?) unc0rr parents: 369 diff changeset	133	Metric:= abs(x1 - x2) + abs(y1 - y2)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	134	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	135
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	136	function TestBazooka(Me: PGear; Targ: TTarget; 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	137	var Vx, Vy, r, mX, mY: real;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 439 diff changeset	138	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	139	EX, EY: LongInt;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	140	valueResult: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	141	x, y, dX, dY: real;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	142	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	143	value: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	144	begin
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5150 diff changeset	145	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	146	mY:= hwFloat2Float(Me^.Y);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	147	ap.Time:= 0;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	148	rTime:= 350;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	149	ap.ExplR:= 0;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	150	valueResult:= BadTurn;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	151	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	152	rTime:= rTime + 300 + Level * 50 + random(300);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	153	Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	154	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	155	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	156	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	157	begin
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	158	x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	159	y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	160	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	161	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	162	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	163	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	164	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	165	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	166	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	167	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	168	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	169	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	170	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	171
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	172	EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	173	EY:= trunc(y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	174	if Level = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	175	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	176	else value:= RateExplosion(Me, EX, EY, 101);
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	177	if (value = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	178	value:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	179	if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	180	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	181	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	182	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	183	ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	184	ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	185	ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	186	valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	187	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	188	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	189	//until (value > 204800) or (rTime > 4250); not so useful since adding score to the drowning
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	190	until rTime > 5050 - Level * 800;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	191	TestBazooka:= valueResult
39 b78e7185ed13 - Increased FPS unc0rr parents: 37 diff changeset	192	end;
374 95169697cc38 - UFO smokes unc0rr parents: 371 diff changeset	193
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	194
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	195	function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	196	var Vx, Vy, r, mX, mY: real;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	197	rTime: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	198	EX, EY: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	199	valueResult: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	200	x, y, dX, dY: real;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	201	t: LongInt;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	202	value: LongInt;
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	203	t2: real;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	204	timer: Longint;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	205	begin
8822 fc9877ff7f1a Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient. nemo parents: 8777 diff changeset	206	if (Level > 3) then exit(BadTurn);
fc9877ff7f1a Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient. nemo parents: 8777 diff changeset	207
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	208	mX:= hwFloat2Float(Me^.X);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	209	mY:= hwFloat2Float(Me^.Y);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	210	ap.Time:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	211	rTime:= 350;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	212	ap.ExplR:= 0;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	213	valueResult:= BadTurn;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	214	repeat
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	215	rTime:= rTime + 300 + Level * 50 + random(300);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	216	Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	217	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	218	r:= sqr(Vx) + sqr(Vy);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	219	if not (r > 1) then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	220	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	221	x:= mX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	222	y:= mY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	223	dX:= Vx;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	224	dY:= -Vy;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	225	t:= rTime;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	226	repeat
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	227	x:= x + dX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	228	y:= y + dY;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	229	dX:= dX + windSpeed;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	230	dY:= dY + cGravityf;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	231	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	232	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	233	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (y > cWaterLine);
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	234
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	235	if TestCollExcludingObjects(trunc(x), trunc(y), 5) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	236	begin
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	237	timer := 500;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	238	t2 := 0.5 / sqrt(sqr(dX) + sqr(dY));
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	239	dX := dX * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	240	dY := dY * t2;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	241	repeat
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	242	x:= x + dX;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	243	y:= y + dY;
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	244	dec(timer);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	245	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 22)
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	246	or (x < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	247	or (y < 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	248	or (trunc(x) > LAND_WIDTH)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	249	or (trunc(y) > LAND_HEIGHT)
9136 78f087fd3e5b parsing ok, stops at uGears koda parents: 9127 diff changeset	250	or (not TestCollExcludingObjects(trunc(x), trunc(y), 5))
8777 cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	251	or (timer = 0)
cce79a042cfc merge. hate the fact that "unsynced remote changes" is just a "note" now. nemo parents: 8751 diff changeset	252	end;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	253	EX:= trunc(x);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	254	EY:= trunc(y);
8862 85eb1f4b4a5f drill test tweak based on watching AI play nemo parents: 8824 diff changeset	255	// Try to prevent AI from thinking firing into water will cause a drowning
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	256	if (EY < cWaterLine-5) and (Timer > 0) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then exit(BadTurn);
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	257	if Level = 1 then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	258	value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	259	else value:= RateExplosion(Me, EX, EY, 101);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	260	if valueResult <= value then
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	261	begin
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	262	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	263	ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	264	ap.ExplR:= 100;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	265	ap.ExplX:= EX;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	266	ap.ExplY:= EY;
8824 fe9eacd390f2 Unbreak lua localisation, fix untranslated login prompt, update translations. nemo parents: 8822 diff changeset	267	valueResult:= value-2500 // trying to make it slightly less attractive than a bazooka, to prevent waste. AI could use awareness of weapon count
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	268	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	269	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	270	until rTime > 5050 - Level * 800;
8033 4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	271	TestDrillRocket:= valueResult
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	272	end;
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	273
4e40503e2b2c Pretend AI knows how to use drill rocket (actually has no idea of drilling) unc0rr parents: 8013 diff changeset	274
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	275	function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	276	var Vx, Vy, r: real;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	277	rTime: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	278	EX, EY: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	279	valueResult: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	280	x, y, dX, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	281	t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	282	value: LongInt;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	283
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	284	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	285	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	286	meY:= hwFloat2Float(Me^.Y);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	287	ap.Time:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	288	rTime:= 350;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	289	ap.ExplR:= 0;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	290	valueResult:= BadTurn;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	291	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	292	rTime:= rTime + 300 + Level * 50 + random(1000);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	293	Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	294	Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	295	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	296	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	297	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	298	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	299	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	300	dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	301	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	302	t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	303	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	304	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	305	y:= y + dY;
7078 a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition nemo parents: 7041 diff changeset	306	dX:= dX + windSpeed;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	307	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	308	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	309	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	310	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	311	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	312	EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	313
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	314	value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall);
8013 5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	315	// LOL copypasta: this is score for digging with... snowball
5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	316	//if value = 0 then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	317	// value:= - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	318
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	319	if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	320	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	321	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	322	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	323	ap.ExplR:= 0;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	324	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	325	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	326	valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	327	end;
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	328	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	329	until (rTime > 5050 - Level * 800);
4580 bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	330	TestSnowball:= valueResult
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	331	end;
bd43d9ac6e04 add AI routine nemo parents: 4578 diff changeset	332
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	333	function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	334	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	335	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	336	TestTime: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	337	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	338	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	339	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	340	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	341	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	342	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	343	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	344	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	345	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	346	inc(TestTime, 300);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	347	Vx:= (Targ.Point.X - meX) / TestTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	348	Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	349	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	350	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	351	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	352	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	353	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	354	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	355	t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	356	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	357	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	358	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	359	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	360	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	361	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	362	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	363	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	364	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	365	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	366	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	367	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	368	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	369
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	370	if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	371	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	372	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	373	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	374	ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	375	ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	376	ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	377	valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	378	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	379	end
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	380	until (TestTime > 5050 - Level * 800);
3018 13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking. nemo parents: 2978 diff changeset	381	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	382	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	383
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	384	function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	385	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	386	var Vx, Vy, r: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	387	Score, EX, EY, valueResult: LongInt;
9145 6b51a32e48ed Fix more warnings (lol @ icegun "consts") unc0rr parents: 9137 diff changeset	388	TestTime: LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	389	x, y, meX, meY, dY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	390	t: LongInt;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	391	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	392	valueResult:= BadTurn;
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	393	TestTime:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	394	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	395	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	396	meY:= hwFloat2Float(Me^.Y);
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	397	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	398	inc(TestTime, 1000);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	399	Vx:= (Targ.Point.X - meX) / (TestTime + tDelta);
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	400	Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	401	r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	402	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	403	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	404	x:= meX;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	405	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	406	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	407	t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	408	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	409	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	410	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	411	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	412	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	413	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	414	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	415	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	416	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	417	if t < 50 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	418	if Level = 1 then
7161 21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain. nemo parents: 7154 diff changeset	419	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	420	else Score:= RateExplosion(Me, EX, EY, 101)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	421	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	422	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	423
8013 5cbf6e4361f4 Various tweaks to recent AI change unc0rr parents: 7873 diff changeset	424	if (valueResult < Score) and (Score > 0) then
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	425	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	426	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 3));
b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	427	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 20);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	428	ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	429	ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	430	ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	431	ap.ExplY:= EY;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	432	valueResult:= Score
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	433	end;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	434	end
6772 13d13aefa4de small tweak. make drowning prefer higher health hogs nemo parents: 6771 diff changeset	435	//until (Score > 204800) or (TestTime > 4000);
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	436	until TestTime > 4500 - Level * 512;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	437	TestGrenade:= valueResult
66 9643d75baf1e Many AI improvements, bots do think in separate thread unc0rr parents: 64 diff changeset	438	end;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	439
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	440	function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	441	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	442	var Vx, Vy, r: real;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	443	Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	444	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	445	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	446	t: LongInt;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	447	begin
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	448	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	449	TestTime:= 500;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	450	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	451	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	452	meY:= hwFloat2Float(Me^.Y);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	453	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	454	inc(TestTime, 900);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	455	// Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	456	if meX<Targ.Point.X then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	457	Vx:= ((Targ.Point.X+10) - meX) / (TestTime + tDelta)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	458	else
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	459	Vx:= ((Targ.Point.X-10) - meX) / (TestTime + tDelta);
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	460	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	461	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	462	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	463	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	464	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	465	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	466	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	467	t:= TestTime;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	468	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	469	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	470	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	471	dY:= dY + cGravityf;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	472	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	473	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	474	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	475	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	476	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	477	if t < 50 then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	478	Score:= RateExplosion(Me, EX, EY, 41)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	479	else
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	480	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	481
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	482	if Score > 0 then
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	483	begin
8903 b35752efd5df Reduce AI skills more on high Level values unc0rr parents: 8895 diff changeset	484	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 2));
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	485	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	486	ap.Time:= TestTime div 1000 * 1000;
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	487	ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	488	ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	489	ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	490	valueResult:= Score
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	491	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	492	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	493	until (TestTime = 4100);
2978 e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	494	TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	495	end;
e71efb31dee3 Same approach for cluster bomb. nemo parents: 2973 diff changeset	496
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	497	function TestWatermelon(Me: PGear; Targ: TTarget; 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	498	const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	499	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	500	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	501	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	502	x, y, dY, meX, meY: real;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	503	t: LongInt;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	504	begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	505	valueResult:= BadTurn;
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	506	TestTime:= 500;
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	507	ap.ExplR:= 0;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	508	meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	509	meY:= hwFloat2Float(Me^.Y);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	510	repeat
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	511	inc(TestTime, 900);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	512	Vx:= (Targ.Point.X - meX) / (TestTime + tDelta);
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	513	Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	514	r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	515	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	516	begin
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	517	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	518	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	519	dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	520	t:= TestTime;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	521	repeat
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	522	x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	523	y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	524	dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	525	dec(t)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	526	until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	527	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	528
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	529	EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	530	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	531	if t < 50 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	532	Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	533	else
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	534	Score:= BadTurn;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	535
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	536	if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	537	begin
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	538	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	539	ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	540	ap.Time:= TestTime div 1000 * 1000;
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	541	ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	542	ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	543	ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	544	valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	545	end;
baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	546	end
7441 5d64f59f2ca5 Better prediction of cluster, melon, and whip unc0rr parents: 7433 diff changeset	547	until (TestTime = 4100);
2973 b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	548	TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	549	end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness. nemo parents: 2948 diff changeset	550
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	551
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	552	function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	553	var A, B, D, T: real;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	554	C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	555	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	556	A:= sqr(cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	557	B:= - cGravityf * (TY - MY) - 1;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	558	C:= sqr(TY - MY) + sqr(TX - MX);
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	559	D:= sqr(B) - A * C;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	560	if D >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	561	begin
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	562	D:= sqrt(D) - B;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	563	if D >= 0 then
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	564	T:= sqrt(D * 2 / A)
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	565	else
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	566	T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	567	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	568	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	569	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	570	Solve:= 0
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	571	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	572
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	573	function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	574	//const tDelta = 24;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	575	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	576	Score, EX, EY: LongInt;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	577	TestTime: Longword;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	578	x, y, dY, meX, meY: real;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	579	begin
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	580	TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	581	ap.ExplR:= 0;
7790 040fc517fece - Fix desyncs triggered by AI unc0rr parents: 7789 diff changeset	582
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	583	meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	584	meY:= hwFloat2Float(Me^.Y);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	585
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	586	if (Level > 2) then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	587	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	588
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	589	TestTime:= Solve(Targ.Point.X, Targ.Point.Y, trunc(meX), trunc(meY));
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	590
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	591	if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	592	exit(BadTurn);
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	593
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	594	Vx:= (Targ.Point.X - meX) / TestTime;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	595	Vy:= cGravityf * (TestTime div 2) - (Targ.Point.Y - meY) / TestTime;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	596
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	597	x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	598	y:= meY;
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	599	dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	600
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	601	repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	602	x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	603	y:= y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	604	dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	605	EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	606	EY:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	607	until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	608	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, EX, EY, 4))) or (EY > cWaterLine);
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	609
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	610	if (EY < cWaterLine) and (dY >= 0) then
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	611	begin
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	612	Score:= RateExplosion(Me, EX, EY, 91);
9005 15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	613	if (Score = 0) then
15a6ed0bd074 Fix mortar's scoring unc0rr parents: 8998 diff changeset	614	if (dY > 0.15) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	615	Score:= - abs(Targ.Point.Y - EY) div 32
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	616	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	617	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	618	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	619	Score:= BadTurn
6474 42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	620	end
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	621	else
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	622	Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions unc0rr parents: 6453 diff changeset	623
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	624	if Score > 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	625	begin
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	626	ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	627	ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	628	ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	629	ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	630	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	631	TestMortar:= Score
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2695 diff changeset	632	end;
994 ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	633	end;
ea415d03968c - Bots can use mortar unc0rr parents: 983 diff changeset	634
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	635	function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	636	const
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	637	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	638	MAX_RANGE = 400;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	639	var Vx, Vy, x, y: real;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	640	rx, ry, valueResult: LongInt;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	641	range: integer;
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	642	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	643	TestShotgun:= BadTurn;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	644	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	645	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	646	ap.Power:= 1;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	647	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	648	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	649	range:= Metric(trunc(x), trunc(y), Targ.Point.X, Targ.Point.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	650	if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	651	exit(BadTurn);
76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	652
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	653	Vx:= (Targ.Point.X - x) * 1 / 1024;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	654	Vy:= (Targ.Point.Y - y) * 1 / 1024;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	655	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	656	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	657	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	658	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	659	rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	660	ry:= trunc(y);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	661	if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or
8895 95177c18e38c Change collision detection with current hedgehog jaree parents: 8862 diff changeset	662	((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, rx, ry, 2)) then
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	663	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	664	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	665	y:= y + vY * 8;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	666	valueResult:= RateShotgun(Me, vX, vY, rx, ry);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	667
8998 d38fb4158342 trying to prevent the AI from attacking barrels. feedback on this welcome. nemo parents: 8974 diff changeset	668	if (valueResult = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	669	valueResult:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, rx, ry) div 64
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	670	else
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6894 diff changeset	671	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	672	// 27/20 is reuse bonus
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	673	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	674	end
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	675	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	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);
4157 f8898d6cca6e Fix some warnings unc0rr parents: 3963 diff changeset	680
375 18012da67681 AI works properly unc0rr parents: 374 diff changeset	681	TestShotgun:= BadTurn
70 82d93eeecebe - Many AI improvements unc0rr parents: 66 diff changeset	682	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	683
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	684	function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8971 fcb29a13b1b1 Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing. nemo parents: 8959 diff changeset	685	var Vx, Vy, x, y, t: real;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	686	d: Longword;
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	687	{fallDmg, }valueResult: LongInt;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	688	begin
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	689	if (Level > 4) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn);
3407 dcc129c4352e Engine: smxx parents: 3384 diff changeset	690	Level:= Level; // avoid compiler hint
8952 a6ee1e7310fb trying to make AI aware of mine/explosive break point. also remove redundant test. nemo parents: 8950 diff changeset	691	ap.ExplR:= 1;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	692	ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	693	ap.Power:= 1;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	694
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	695	x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	696	y:= hwFloat2Float(Me^.Y);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	697
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	698	if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 20 then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	699	exit(BadTurn);
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	700
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	701	t:= 2 / sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y));
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	702	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	703	Vy:= (Targ.Point.Y - y) * t;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	704	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	705	d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	706
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	707	repeat
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	708	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	709	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	710	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	711	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	712	inc(d);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	713	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 5)
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	714	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	715	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	716	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	717	or (trunc(y) > LAND_HEIGHT)
7760 ccc8bd5205ff Tweak TestDesertEagle. Bots should prefer direct shots to shots through land now, but I didn't test that yet. unc0rr parents: 7752 diff changeset	718	or (d > 48);
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	719
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	720	if Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 5 then
9495 2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	721	begin
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	722	ap.AttacksNum:= 1 + (d + 8) div 12;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	723	valueResult:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, 7, 20, vX0.125, vY0.125, afTrackFall) - ap.AttacksNum
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	724	end
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	725	else
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	726	valueResult:= BadTurn;
2fc346fadae3 - AI quickly shoots with desert eagle till hits the target unc0rr parents: 9145 diff changeset	727
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	728	TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	729	end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	730
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	731
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	732	function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
8971 fcb29a13b1b1 Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing. nemo parents: 8959 diff changeset	733	var Vx, Vy, x, y, t, dmg: real;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	734	d: Longword;
9137 d987230b85ed fixed all engine compilation hints and notes (that I could see) sheepluva parents: 9080 diff changeset	735	//fallDmg: LongInt;
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	736	begin
8974 d360e97ce842 I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels. nemo parents: 8971 diff changeset	737	if (Level > 3) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn);
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	738	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	739	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	740	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	741	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	742	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	743	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	744	if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 40 then
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	745	exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	746
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	747	dmg:= sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y));
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	748	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	749	dmg:= dmg * 0.025; // div 40
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	750	Vx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	751	Vy:= (Targ.Point.Y - y) * t;
6894 555a8d8db228 Some more progress with pas2c unc0rr parents: 6888 diff changeset	752	ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	753	d:= 0;
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	754
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	755	repeat
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	756	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	757	y:= y + vY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	758	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	759	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	760	inc(d);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	761	until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4)
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	762	or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	763	or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	764	or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	765	or (trunc(y) > LAND_HEIGHT)
7873 266fe9f1e5a9 Improve TestSniperRifle a bit unc0rr parents: 7790 diff changeset	766	or (d > 22);
1941 b1ef1f86148c Some AI tweaks by imcold unc0rr parents: 1854 diff changeset	767
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	768	if Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4 then
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	769	TestSniperRifle:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, trunc(dmg), 20, vX0.166, vY0.166, afTrackFall)
8952 a6ee1e7310fb trying to make AI aware of mine/explosive break point. also remove redundant test. nemo parents: 8950 diff changeset	770	else TestSniperRifle:= BadTurn;
75 d2b737858ff7 - New First Aid powerup unc0rr parents: 74 diff changeset	771	end;
438 04bcc3fb127a Fix AI using shotgun and Desert Eagle unc0rr parents: 434 diff changeset	772
7197 5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much) unc0rr parents: 7178 diff changeset	773
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	774	function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	775	var valueResult, a, v1, v2: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	776	x, y, trackFall: LongInt;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	777	dx, dy: real;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	778	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	779	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	780
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	781	if Level < 3 then trackFall:= afTrackFall
8026 4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions) koda parents: 8013 diff changeset	782	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	783
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	784	ap.ExplR:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	785	ap.Time:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	786	ap.Power:= 1;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	787	x:= hwRound(Me^.X);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	788	y:= hwRound(Me^.Y);
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	789
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	790	a:= cMaxAngle div 2;
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	791	valueResult:= 0;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	792
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	793	while a >= 0 do
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	794	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	795	dx:= sin(a / cMaxAngle * pi) * 0.5;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	796	dy:= cos(a / cMaxAngle * pi) * 0.5;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	797
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	798	v1:= RateShove(Me, x - 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	799	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	800	, -dx, -dy, trackFall);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	801	v2:= RateShove(Me, x + 10, y + 2
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	802	, 32, 30, 115
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	803	, dx, -dy, trackFall);
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	804	if (v1 > valueResult) or (v2 > valueResult) then
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	805	if (v2 > v1)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	806	or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	807	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	808	ap.Angle:= a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	809	valueResult:= v2
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	810	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	811	else
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	812	begin
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	813	ap.Angle:= -a;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	814	valueResult:= v1
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	815	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	816
7424 fe0f07667f24 Prefer to bat enemy away dealing the same amount of damage unc0rr parents: 7416 diff changeset	817	a:= a - 15 - random(cMaxAngle div 16)
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	818	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	819
7212 ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	820	if valueResult <= 0 then
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	821	valueResult:= BadTurn;
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	822
ab60dbe8fd0c TestBaseballBat unc0rr parents: 7210 diff changeset	823	TestBaseballBat:= valueResult;
79 29b477319854 - New test map unc0rr parents: 78 diff changeset	824	end;
29b477319854 - New test map unc0rr parents: 78 diff changeset	825
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	826	function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	827	var valueResult, v1, v2, i: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	828	x, y, trackFall: LongInt;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	829	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	830	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	831
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	832	if Level = 1 then trackFall:= afTrackFall
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	833	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	834
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	835	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	836	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	837	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	838	x:= hwRound(Me^.X);
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	839	y:= hwRound(Me^.Y) + 4;
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	840
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	841	v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	842	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	843	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	844	v1:= v1 + RateShove(Me, x - 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	845	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	846	, -0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	847	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	848	v1:= v1 + RateShove(Me, x - 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	849	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	850	, -0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	851
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	852
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	853	// now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	854	v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	855	for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	856	begin
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	857	v2:= v2 + RateShove(Me, x + 5, y - 10 * i
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	858	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	859	, 0.45, -0.9, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	860	end;
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	861	v2:= v2 + RateShove(Me, x + 5, y - 90
7427 48f9d53c844a Adjust firepunch and bat consts yet again unc0rr parents: 7424 diff changeset	862	, 19, 30, 40
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	863	, 0.45, -0.9, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	864
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	865	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	866	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	867	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	868	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	869	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	870	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	871	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	872	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	873	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	874	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	875	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	876
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	877	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	878	valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	879
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	880	TestFirePunch:= valueResult;
82 2f4f3236cccc - New fort unc0rr parents: 80 diff changeset	881	end;
433 9f8f22094c0e AI thinks in separate thread unc0rr parents: 409 diff changeset	882
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	883
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	884	function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	885	var valueResult, v1, v2: LongInt;
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	886	x, y, trackFall: LongInt;
6770 7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat. nemo parents: 6769 diff changeset	887	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	888	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	889
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	890	if Level = 1 then trackFall:= afTrackFall
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	891	else trackFall:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	892
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	893	ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	894	ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	895	ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	896	x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	897	y:= hwRound(Me^.Y);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	898
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	899	// check left direction
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	900	{first RateShove checks farthermost of two whip's AmmoShove attacks
13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	901	to encourage distant attacks (damaged hog is excluded from view of second
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	902	RateShove call)}
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	903	v1:= RateShove(Me, x - 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	904	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	905	, -1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	906	v1:= v1 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	907	RateShove(Me, x - 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	908	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	909	, -1, -0.8, trackFall);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	910	// now try opposite direction
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	911	v2:= RateShove(Me, x + 13, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	912	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	913	, 1, -0.8, trackFall or afSetSkip);
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	914	v2:= v2 +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	915	RateShove(Me, x + 2, y
7210 2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly unc0rr parents: 7208 diff changeset	916	, 30, 30, 25
7348 2a69f2ed9273 Limit firepunch/whip drowning checks to max AI, bat to top 2 levels. nemo parents: 7274 diff changeset	917	, 1, -0.8, trackFall);
7154 56e329edf4b8 Improve TestWhip unc0rr parents: 7134 diff changeset	918
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	919	if (v2 > v1)
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	920	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	921	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	922	ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	923	valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	924	end
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	925	else
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	926	begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	927	ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	928	valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	929	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	930
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	931	if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	932	valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	933	else
744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	934	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	935
7200 744c8a5546c6 New bright and shiny TestFirepunch which actually works unc0rr parents: 7197 diff changeset	936	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	937	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	938
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	939	function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	940	const step = 8;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	941	var valueResult, i, v, tx: LongInt;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	942	trackFall: LongInt;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	943	t, d, x, y, dx, dy, cx: real;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	944	begin
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	945	ap.ExplR:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	946	ap.Time:= 0;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	947	ap.Power:= 1;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	948
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	949	if Level = 1 then
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	950	trackFall:= afTrackFall
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	951	else if Level = 2 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	952	trackFall:= 0
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	953	else
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	954	exit(BadTurn);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	955
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	956	valueResult:= 0;
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	957	v:= 0;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	958
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	959	x:= hwFloat2Float(Me^.X);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	960	y:= hwFloat2Float(Me^.Y);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	961	d:= sqrt(sqr(Targ.Point.X - x) + sqr(Targ.Point.Y - y));
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	962	if d < 10 then
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	963	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	964	dx:= 0;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	965	dy:= 8;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	966	ap.Angle:= 2048
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	967	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	968	else
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	969	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	970	t:= step / d;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	971	dx:= (Targ.Point.X - x) * t;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	972	dy:= (Targ.Point.Y - y) * t;
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	973
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	974	ap.Angle:= DxDy2AttackAnglef(dx, -dy)
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	975	end;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	976
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	977	if dx >= 0 then cx:= 0.45 else cx:= -0.45;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	978
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	979	for i:= 0 to 512 div step - 2 do
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	980	begin
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	981	valueResult:= valueResult +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	982	RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	983	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	984	, cx, -0.9, trackFall or afSetSkip);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	985
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	986	x:= x + dx;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	987	y:= y + dy;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	988	end;
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	989	if dx = 0 then
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	990	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	991	x:= hwFloat2Float(Me^.X);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	992	y:= hwFloat2Float(Me^.Y);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	993	tx:= trunc(x);
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	994	v:= RateShove(Me, tx, trunc(y)
7486 f3a13da9fa4e oops nemo parents: 7474 diff changeset	995	, 30, 30, 25
f3a13da9fa4e oops nemo parents: 7474 diff changeset	996	, -cx, -0.9, trackFall);
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	997	for i:= 1 to 512 div step - 2 do
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	998	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	999	y:= y + dy;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1000	v:= v +
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1001	RateShove(Me, tx, trunc(y)
7474 bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1002	, 30, 30, 25
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1003	, -cx, -0.9, trackFall or afSetSkip);
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1004	end
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1005	end;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1006	if v > valueResult then
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1007	begin
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1008	ap.Angle:= -2048;
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1009	valueResult:= v
bbecb1b4f59b Fix kamikaze crasher. Handle overlapping hogs case. nemo parents: 7471 diff changeset	1010	end;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1011
8950 3bf81ed1f984 Make hogs aware of dud mines and explosives. Still a bit more needed. nemo parents: 8924 diff changeset	1012	v:= RateShove(Me, trunc(x), trunc(y)
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1013	, 30, 30, 25
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1014	, cx, -0.9, trackFall);
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1015	valueResult:= valueResult + v - KillScore * friendlyfactor div 100 * 1024;
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1016
7471 ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1017	if v < 65536 then
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1018	inc(valueResult, RateExplosion(Me, trunc(x), trunc(y), 30));
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1019
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1020	TestKamikaze:= valueResult;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1021	end;
ce5d3e39361e TestKamikaze, needs polishing unc0rr parents: 7441 diff changeset	1022
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1023	function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1024	var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1025	begin
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1026	Level:= Level; // avoid compiler hint
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1027	Targ:= Targ;
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1028
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1029	ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1030	ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1031	ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1032	ap.Angle:= 0;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1033
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	1034	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	1035	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	1036	rate:= BadTurn;
5645 b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1037	TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1038	end;
b434ba5d064e Implement TestHammer which makes sense unc0rr parents: 5642 diff changeset	1039
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1040	function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
556 49675457d76e Bots aims not directly at the center of enemy hedgehog unc0rr parents: 554 diff changeset	1041	const cShift = 4;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1042	var bombsSpeed, X, Y, dY: real;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1043	b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1044	dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1045	fexit: boolean;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1046	i, t, valueResult: LongInt;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1047	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1048	ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1049	ap.Time:= 0;
9844 8f5b48525a03 quick sanity change for AI + zerog nemo parents: 9790 diff changeset	1050	if (Level > 3) or (cGravityf = 0) then
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1051	exit(BadTurn);
554 4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon unc0rr parents: 543 diff changeset	1052
7132 baf3351646f4 - Fix some AI stupidness factors unc0rr parents: 7078 diff changeset	1053	ap.Angle:= 0;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1054	ap.AttackPutX:= Targ.Point.X;
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1055	ap.AttackPutY:= Targ.Point.Y;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1056
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1057	bombsSpeed:= hwFloat2Float(cBombsSpeed);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1058	X:= Targ.Point.X - 135 - cShift; // hh center - cShift
ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1059	X:= X - bombsSpeed * sqrt(((Targ.Point.Y + 128) * 2) / cGravityf);
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1060	Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1061	dY:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1062
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1063	for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1064	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1065	b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1066	dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1067	end;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1068	valueResult:= 0;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1069
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1070	repeat
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1071	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	1072	Y:= Y + dY;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1073	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	1074	fexit:= true;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1075
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1076	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	1077	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	1078	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1079	fexit:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1080	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	1081	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1082	b[i]:= false;
6992 b8f3d8991e92 marked a couple of functions as inline koda parents: 6990 diff changeset	1083	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	1084	// 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	1085	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1086	end;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6774 diff changeset	1087	until fexit or (Y > cWaterLine);
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1088
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1089	for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1090	t:= valueResult;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1091	ap.AttackPutX:= Targ.Point.X - 60;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1092
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1093	for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1094	begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1095	dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1096	inc(t, dmg[i + 6]);
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1097	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	1098	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1099	valueResult:= t;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1100	ap.AttackPutX:= Targ.Point.X - 30 - cShift + i * 30
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1101	end
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1102	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1103
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1104	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	1105	valueResult:= BadTurn;
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2630 diff changeset	1106	TestAirAttack:= valueResult;
543 465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1107	end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land unc0rr parents: 534 diff changeset	1108
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1109
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1110	function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1111	var
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1112	i, failNum: longword;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1113	maxTop: longword;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1114	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1115	TestTeleport := BadTurn;
7041 76a9274f280f More definitions and mess with pascal code unc0rr parents: 7007 diff changeset	1116	exit(BadTurn);
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1117	Level:= Level; // avoid compiler hint
6888 32a54322d262 Get rid of TGearsType to simplify pas2c unc0rr parents: 6879 diff changeset	1118	//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	1119	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	1120	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1121	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	1122	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1123	maxTop := Targ.Point.Y - cHHRadius * 2;
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1124
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1125	while not TestColl(Targ.Point.X, maxTop, cHHRadius) and (maxTop > topY + cHHRadius * 2 + 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1126	dec(maxTop, cHHRadius*2);
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1127	if not TestColl(Targ.Point.X, maxTop + cHHRadius, cHHRadius) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1128	begin
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1129	ap.AttackPutX := Targ.Point.X;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1130	ap.AttackPutY := maxTop + cHHRadius;
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1131	TestTeleport := Targ.Point.Y - maxTop;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1132	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1133	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1134	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1135	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1136	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1137	failNum := 0;
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3677 diff changeset	1138	repeat
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1139	i := random(bonuses.Count);
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1140	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	1141	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	1142	or (failNum = bonuses.Count*2);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1143
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6474 diff changeset	1144	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	1145	begin
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1146	ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1147	ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1148	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	1149	end;
3439 a98984e4f458 Teleport AI: mbait parents: 3438 diff changeset	1150	end;
3370 37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1151	end;
37f4f83fedb1 Teleport AI: mbait parents: 3350 diff changeset	1152
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1153
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1154	procedure checkCakeWalk(Me, Gear: PGear; var ap: TAttackParams);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1155	var i: Longword;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1156	v: LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1157	begin
8370 0c79946e96f8 Fix tons of warnings martin_bede parents: 8161 diff changeset	1158	while (not TestColl(hwRound(Gear^.X), hwRound(Gear^.Y), 6)) and (Gear^.Y.Round < LongWord(LAND_HEIGHT)) do
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1159	Gear^.Y:= Gear^.Y + _1;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1160
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1161	for i:= 0 to 2040 do
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1162	begin
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1163	cakeStep(Gear);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1164	v:= RateExplosion(Me, hwRound(Gear^.X), hwRound(Gear^.Y), cakeDmg * 2, afTrackFall);
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8903 diff changeset	1165	if v > ap.Power then
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1166	begin
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1167	ap.ExplX:= hwRound(Gear^.X);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1168	ap.ExplY:= hwRound(Gear^.Y);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1169	ap.Power:= v
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1170	end
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1171	end;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1172	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1173
8959 ad680848a5c9 pass the target nemo parents: 8952 diff changeset	1174	function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1175	var valueResult, v1, v2: LongInt;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1176	cake: TGear;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1177	begin
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1178	Targ:= Targ; // avoid compiler hint
95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1179
7501 1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1180	if (Level > 2) then
1763dc3bc9b7 no cake for youuuuu nemo parents: 7486 diff changeset	1181	exit(BadTurn);
7716 95117607b81a Fix some hints unc0rr parents: 7671 diff changeset	1182
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1183	ap.ExplR:= 0;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1184	ap.Time:= 0;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1185	ap.Power:= BadTurn; // use it as max score value in checkCakeWalk
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1186
7721 2b1ad418ba39 - Fix warnings and hints unc0rr parents: 7716 diff changeset	1187	//FillChar(cake, sizeof(cake), 0);
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1188	cake.Radius:= 7;
8751 4609823efc94 More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places. nemo parents: 8744 diff changeset	1189	cake.CollisionMask:= lfNotCurrentMask;
7752 65bacd3ba69e Fix crasher in TestCake unc0rr parents: 7730 diff changeset	1190	cake.Hedgehog:= Me^.Hedgehog;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1191
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1192	// check left direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1193	cake.Angle:= 3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1194	cake.dX.isNegative:= true;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1195	cake.X:= Me^.X - _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1196	cake.Y:= Me^.Y;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1197	checkCakeWalk(Me, @cake, ap);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1198	v1:= ap.Power;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1199
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1200	// now try opposite direction
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1201	cake.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1202	cake.dX.isNegative:= false;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1203	cake.X:= Me^.X + _3;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1204	cake.Y:= Me^.Y;
7416 2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1205	checkCakeWalk(Me, @cake, ap);
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1206	v2:= ap.Power;
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1207
2f2f78fc65a3 AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog. unc0rr parents: 7398 diff changeset	1208	ap.Power:= 1;
7398 2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1209
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1210	if (v2 > v1) then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1211	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1212	ap.Angle:= 1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1213	valueResult:= v2
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1214	end
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1215	else
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1216	begin
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1217	ap.Angle:= -1;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1218	valueResult:= v1
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1219	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1220
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1221	if valueResult <= 0 then
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1222	valueResult:= BadTurn;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1223
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1224	TestCake:= valueResult;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1225	end;
2b7b939014b5 Start TestCake unc0rr parents: 7375 diff changeset	1226
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1227	function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1228	var valueResult: LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1229	x, y, dx, dy: real;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1230	EX, EY, t: LongInt;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1231	begin
9790 0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1232	Targ:= Targ; // avoid compiler hint
0b4b9fda5bd4 - /owner command to specify team owner unc0rr parents: 9768 diff changeset	1233
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1234	x:= hwFloat2Float(Me^.X) + hwSign(Me^.dX) * 7;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1235	y:= hwFloat2Float(Me^.Y);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1236	dx:= hwSign(Me^.dX) * 0.03;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1237	dy:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1238	t:= 5000;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1239	repeat
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1240	dec(t);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1241	x:= x + dx;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1242	dy:= dy + cGravityf;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1243	y:= y + dy;
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1244
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1245	if TestColl(trunc(x), trunc(y), 3) then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1246	t:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1247	until t = 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1248
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1249	EX:= trunc(x);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1250	EY:= trunc(y);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1251
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1252	if Level = 1 then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1253	valueResult:= RateExplosion(Me, EX, EY, 76, afTrackFall or afErasesLand)
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	1254	else
9722 22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1255	valueResult:= RateExplosion(Me, EX, EY, 76);
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1256
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1257	if (valueResult > 0) then
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1258	begin
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1259	ap.Angle:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1260	ap.Power:= 1;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1261	ap.Time:= 0;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1262	ap.ExplR:= 150;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1263	ap.ExplX:= EX;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1264	ap.ExplY:= EY
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1265	end else
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1266	valueResult:= BadTurn;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1267
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1268	TestDynamite:= valueResult
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1269	end;
22dba2d8de93 Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs. unc0rr parents: 9495 diff changeset	1270
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	1271	end.

author	unc0rr
	Wed, 22 Jan 2014 09:19:08 +0400
changeset 10049	ca11d122f54e
parent 10015	4feced261c68
child 10097	acef073e190f
permissions	-rw-r--r--