hedgewars-draft: hedgewars/uCollisions.pas@148bb90d7e32 (annotated)

4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	1	(*
1066 1f1b3686a2b0 Update copyright headers a bit unc0rr parents: 967 diff changeset	2	* Hedgewars, a free turn based strategy game
11046 47a8c19ecb60 more copyright fixes sheepluva parents: 10818 diff changeset	3	* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com>
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	4	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	5	* This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	6	* it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	7	* the Free Software Foundation; version 2 of the License
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	8	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	9	* This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	12	* GNU General Public License for more details.
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	13	*
183 57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	14	* You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL unc0rr parents: 107 diff changeset	15	* along with this program; if not, write to the Free Software
10108 c68cf030eded update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers sheepluva parents: 10015 diff changeset	16	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	17	*)
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	18
2630 079ef82eac75 revamped file access and debug display koda parents: 2599 diff changeset	19	{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display koda parents: 2599 diff changeset	20
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	21	unit uCollisions;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	22	interface
4357 a1fcfc341a52 Introduce unit uTypes in order to remove some cyclic unit dependencies unC0Rr parents: 3697 diff changeset	23	uses uFloat, uTypes;
2630 079ef82eac75 revamped file access and debug display koda parents: 2599 diff changeset	24
5290 eea7570d345f This can afford to be a bit larger. Does not impact performance. nemo parents: 4976 diff changeset	25	const cMaxGearArrayInd = 1023;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	26
70 82d93eeecebe - Many AI improvements unc0rr parents: 68 diff changeset	27	type PGearArray = ^TGearArray;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	28	TGearArray = record
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	29	ar: array[0..cMaxGearArrayInd] of PGear;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	30	Count: Longword
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	31	end;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	32
3038 4e48c276a468 In pascal unit is a namespace unc0rr parents: 2948 diff changeset	33	procedure initModule;
4e48c276a468 In pascal unit is a namespace unc0rr parents: 2948 diff changeset	34	procedure freeModule;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	35
9291 15f7bb217b66 Make add/delete consistent (this has bugged me for so long) nemo parents: 9247 diff changeset	36	procedure AddCI(Gear: PGear);
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	37	procedure DeleteCI(Gear: PGear);
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	38
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	39	function CheckGearsCollision(Gear: PGear): PGearArray;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	40
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	41	function TestCollisionXwithGear(Gear: PGear; Dir: LongInt): Word;
6081 537bbd5c1a62 Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects. nemo parents: 5919 diff changeset	42	function TestCollisionYwithGear(Gear: PGear; Dir: LongInt): Word;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	43
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	44	function TestCollisionXKick(Gear: PGear; Dir: LongInt): Word;
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	45	function TestCollisionYKick(Gear: PGear; Dir: LongInt): Word;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	46
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	47	function TestCollisionX(Gear: PGear; Dir: LongInt): Word;
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	48	function TestCollisionY(Gear: PGear; Dir: LongInt): Word;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	49
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	50	function TestCollisionXwithXYShift(Gear: PGear; ShiftX: hwFloat; ShiftY: LongInt; Dir: LongInt): Word; inline;
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	51	function TestCollisionXwithXYShift(Gear: PGear; ShiftX: hwFloat; ShiftY: LongInt; Dir: LongInt; withGear: boolean): Word;
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	52	function TestCollisionYwithXYShift(Gear: PGear; ShiftX, ShiftY: LongInt; Dir: LongInt): Word; inline;
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	53	function TestCollisionYwithXYShift(Gear: PGear; ShiftX, ShiftY: LongInt; Dir: LongInt; withGear: boolean): Word;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	54
10818 f642a28cab0c Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget nemo parents: 10635 diff changeset	55	function TestRectangleForObstacle(x1, y1, x2, y2: LongInt; landOnly: boolean): boolean;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	56
10354 56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	57	function CheckCoordInWater(X, Y: LongInt): boolean; inline;
56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	58
9248 3e8558dc285a BOM, pas2c only support ASCII koda parents: 9080 diff changeset	59	// returns: negative sign if going downhill to left, value is steepness (noslope/error = _0, 45 = _0_5)
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	60	function CalcSlopeBelowGear(Gear: PGear): hwFloat;
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	61	function CalcSlopeNearGear(Gear: PGear; dirX, dirY: LongInt): hwFloat;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	62	function CalcSlopeTangent(Gear: PGear; collisionX, collisionY: LongInt; var outDeltaX, outDeltaY: LongInt; TestWord: LongWord): boolean;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	63
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	64	implementation
9737 f0769402350c fix for: uCollisions.pas(63,50) Hint: Unit "uGearsList" not used in uCollisions sheepluva parents: 9731 diff changeset	65	uses uConsts, uLandGraphics, uVariables, uDebug;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	66
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	67	type TCollisionEntry = record
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	68	X, Y, Radius: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	69	cGear: PGear;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	70	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	71
5568 badaac85f9d4 bump up max collision to 1024 entries nemo parents: 5290 diff changeset	72	const MAXRECTSINDEX = 1023;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	73	var Count: Longword;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	74	cinfos: array[0..MAXRECTSINDEX] of TCollisionEntry;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	75	ga: TGearArray;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	76
9291 15f7bb217b66 Make add/delete consistent (this has bugged me for so long) nemo parents: 9247 diff changeset	77	procedure AddCI(Gear: PGear);
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	78	begin
10551 4eefc711309e Skip checkin on collision for frequently spammed gear types if collision gets huge instead of trying to delete mines. nemo parents: 10494 diff changeset	79	if (Gear^.CollisionIndex >= 0) or
4eefc711309e Skip checkin on collision for frequently spammed gear types if collision gets huge instead of trying to delete mines. nemo parents: 10494 diff changeset	80	((Count > MAXRECTSINDEX-200) and ((Gear^.Kind = gtMine) or (Gear^.Kind = gtSMine) or (Gear^.Kind = gtKnife))) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	81	exit;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	82	TryDo(Count <= MAXRECTSINDEX, 'Collision rects array overflow', true);
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	83	with cinfos[Count] do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	84	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	85	X:= hwRound(Gear^.X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	86	Y:= hwRound(Gear^.Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	87	Radius:= Gear^.Radius;
9247 68bbe56badcc poor AI thought he should avoid stepping on frozen crates, and jump for non-frozen ones nemo parents: 9080 diff changeset	88	ChangeRoundInLand(X, Y, Radius - 1, true, (Gear = CurrentHedgehog^.Gear) or ((Gear^.Kind = gtCase) and (Gear^.State and gstFrozen = 0)));
3608 c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	89	cGear:= Gear
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	90	end;
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	91	Gear^.CollisionIndex:= Count;
5569 8313952b2811 suggestion of mikade's - delete old mines if the collision array shows signs of filling up. This is kind of an edge case, esp now that array is up to 1024, but should prevent (easiest) way to crash by collision array overflow (endless mines/minestrikes). nemo parents: 5568 diff changeset	92	inc(Count);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	93	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	94
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	95	procedure DeleteCI(Gear: PGear);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	96	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	97	if Gear^.CollisionIndex >= 0 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	98	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	99	with cinfos[Gear^.CollisionIndex] do
10635 8e8b320eefad nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors. nemo parents: 10551 diff changeset	100	ChangeRoundInLand(X, Y, Radius - 1, false, ((CurrentHedgehog <> nil) and (Gear = CurrentHedgehog^.Gear)) or ((Gear^.Kind = gtCase) and (Gear^.State and gstFrozen = 0)));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	101	cinfos[Gear^.CollisionIndex]:= cinfos[Pred(Count)];
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	102	cinfos[Gear^.CollisionIndex].cGear^.CollisionIndex:= Gear^.CollisionIndex;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	103	Gear^.CollisionIndex:= -1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	104	dec(Count)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	105	end;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	106	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	107
10354 56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	108	function CheckCoordInWater(X, Y: LongInt): boolean; inline;
56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	109	begin
56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	110	CheckCoordInWater:= (Y > cWaterLine)
10494 0eb97cf4c78e Fix warnings given by 32-bit fpc unC0Rr parents: 10354 diff changeset	111	or ((WorldEdge = weSea) and ((X < LongInt(leftX)) or (X > LongInt(rightX))));
10354 56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	112	end;
56bd029245fc WIP: weSea tweaks, functional and visual sheepluva parents: 10108 diff changeset	113
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	114	function CheckGearsCollision(Gear: PGear): PGearArray;
3609 bc63ed514b70 Minor fire tweak for readability and lethalness, remove exit condition that was hanging game (identified by jaylittle) nemo parents: 3608 diff changeset	115	var mx, my, tr: LongInt;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	116	i: Longword;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	117	begin
1506 a4ab75470ce1 - Some reformatting unc0rr parents: 1066 diff changeset	118	CheckGearsCollision:= @ga;
53 0e27949850e3 - Fixed bubble theme object unc0rr parents: 38 diff changeset	119	ga.Count:= 0;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	120	if Count = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	121	exit;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	122	mx:= hwRound(Gear^.X);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	123	my:= hwRound(Gear^.Y);
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	124
4705 593ef1ad3cd3 ok. restore old [r + 1 + r] for gear width for a moment, and reset snowballs. nemo parents: 4684 diff changeset	125	tr:= Gear^.Radius + 2;
3609 bc63ed514b70 Minor fire tweak for readability and lethalness, remove exit condition that was hanging game (identified by jaylittle) nemo parents: 3608 diff changeset	126
3608 c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	127	for i:= 0 to Pred(Count) do
c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	128	with cinfos[i] do
c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	129	if (Gear <> cGear) and
3609 bc63ed514b70 Minor fire tweak for readability and lethalness, remove exit condition that was hanging game (identified by jaylittle) nemo parents: 3608 diff changeset	130	(sqr(mx - x) + sqr(my - y) <= sqr(Radius + tr)) then
3608 c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	131	begin
c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	132	ga.ar[ga.Count]:= cinfos[i].cGear;
c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	133	inc(ga.Count)
c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	134	end
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	135	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	136
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	137	function TestCollisionXwithGear(Gear: PGear; Dir: LongInt): Word;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 351 diff changeset	138	var x, y, i: LongInt;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	139	begin
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	140	// Special case to emulate the old intersect gear clearing, but with a bit of slop for pixel overlap
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	141	if (Gear^.CollisionMask = lfNotCurrentMask) and (Gear^.Kind <> gtHedgehog) and (Gear^.Hedgehog <> nil) and (Gear^.Hedgehog^.Gear <> nil) and
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	142	((hwRound(Gear^.Hedgehog^.Gear^.X) + Gear^.Hedgehog^.Gear^.Radius + 16 < hwRound(Gear^.X) - Gear^.Radius) or
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	143	(hwRound(Gear^.Hedgehog^.Gear^.X) - Gear^.Hedgehog^.Gear^.Radius - 16 > hwRound(Gear^.X) + Gear^.Radius)) then
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	144	Gear^.CollisionMask:= $FFFF;
838 1faae19f2116 Remove tailing spaces in some places unc0rr parents: 542 diff changeset	145
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	146	x:= hwRound(Gear^.X);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	147	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	148	x:= x - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	149	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	150	x:= x + Gear^.Radius;
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: 6986 diff changeset	151
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1528 diff changeset	152	if (x and LAND_WIDTH_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	153	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	154	y:= hwRound(Gear^.Y) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	155	i:= y + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	156	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	157	if (y and LAND_HEIGHT_MASK) = 0 then
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	158	if Land[y, x] and Gear^.CollisionMask <> 0 then
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	159	exit(Land[y, x] and Gear^.CollisionMask);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	160	inc(y)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	161	until (y > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	162	end;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	163	TestCollisionXwithGear:= 0
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	164	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	165
6081 537bbd5c1a62 Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects. nemo parents: 5919 diff changeset	166	function TestCollisionYwithGear(Gear: PGear; Dir: LongInt): Word;
505 fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	167	var x, y, i: LongInt;
fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	168	begin
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	169	// Special case to emulate the old intersect gear clearing, but with a bit of slop for pixel overlap
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	170	if (Gear^.CollisionMask = lfNotCurrentMask) and (Gear^.Kind <> gtHedgehog) and (Gear^.Hedgehog <> nil) and (Gear^.Hedgehog^.Gear <> nil) and
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	171	((hwRound(Gear^.Hedgehog^.Gear^.Y) + Gear^.Hedgehog^.Gear^.Radius + 16 < hwRound(Gear^.Y) - Gear^.Radius) or
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	172	(hwRound(Gear^.Hedgehog^.Gear^.Y) - Gear^.Hedgehog^.Gear^.Radius - 16 > hwRound(Gear^.Y) + Gear^.Radius)) then
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	173	Gear^.CollisionMask:= $FFFF;
505 fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	174
fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	175	y:= hwRound(Gear^.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	176	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	177	y:= y - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	178	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	179	y:= y + Gear^.Radius;
7268 3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 6992 diff changeset	180
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1528 diff changeset	181	if (y and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	182	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	183	x:= hwRound(Gear^.X) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	184	i:= x + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	185	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	186	if (x and LAND_WIDTH_MASK) = 0 then
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	187	if Land[y, x] and Gear^.CollisionMask <> 0 then
71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	188	begin
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	189	exit(Land[y, x] and Gear^.CollisionMask)
7272 71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	190	end;
71df899c4163 Second part of the change. Make collision check use the new mask bit. nemo parents: 7270 diff changeset	191	inc(x)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	192	until (x > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	193	end;
6081 537bbd5c1a62 Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects. nemo parents: 5919 diff changeset	194	TestCollisionYwithGear:= 0
505 fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	195	end;
fcba7d7aea0d Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog unc0rr parents: 504 diff changeset	196
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	197	function TestCollisionXKick(Gear: PGear; Dir: LongInt): Word;
3608 c509bbc779e7 Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists. nemo parents: 3603 diff changeset	198	var x, y, mx, my, i: LongInt;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	199	pixel: Word;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	200	begin
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	201	pixel:= 0;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	202	x:= hwRound(Gear^.X);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	203	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	204	x:= x - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	205	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	206	x:= x + Gear^.Radius;
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: 6986 diff changeset	207
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1528 diff changeset	208	if (x and LAND_WIDTH_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	209	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	210	y:= hwRound(Gear^.Y) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	211	i:= y + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	212	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	213	if (y and LAND_HEIGHT_MASK) = 0 then
11077 1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	214	begin
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	215	if Land[y, x] and Gear^.CollisionMask <> 0 then
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	216	begin
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	217	if Land[y, x] and Gear^.CollisionMask > 255 then
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	218	exit(Land[y, x] and Gear^.CollisionMask)
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	219	else
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	220	pixel:= Land[y, x] and Gear^.CollisionMask;
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	221	end;
1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	222	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	223	inc(y)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	224	until (y > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	225	end;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	226	TestCollisionXKick:= pixel;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	227
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	228	if pixel <> 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	229	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	230	if hwAbs(Gear^.dX) < cHHKick then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	231	exit;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	232	if (Gear^.State and gstHHJumping <> 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	233	and (hwAbs(Gear^.dX) < _0_4) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	234	exit;
967 8be3938d73c2 Don't let jumping hedgehog to move others unc0rr parents: 906 diff changeset	235
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	236	mx:= hwRound(Gear^.X);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	237	my:= hwRound(Gear^.Y);
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	238
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	239	for i:= 0 to Pred(Count) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	240	with cinfos[i] do
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	241	if (Gear <> cGear) and
9305 8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	242	((mx > x) xor (Dir > 0)) and
7756 b89bd0ffb8aa Try to prevent a situation where hogs embedded in other hogs/barrels/cleavers get stuck, by checking for gears overlapping on Y nemo parents: 7754 diff changeset	243	(
b89bd0ffb8aa Try to prevent a situation where hogs embedded in other hogs/barrels/cleavers get stuck, by checking for gears overlapping on Y nemo parents: 7754 diff changeset	244	((cGear^.Kind in [gtHedgehog, gtMine, gtKnife]) and ((Gear^.State and gstNotKickable) = 0)) or
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	245	// only apply X kick if the barrel is knocked over
9305 8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	246	((cGear^.Kind = gtExplosives) and ((cGear^.State and gsttmpflag) <> 0))
8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	247	) and
8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	248	(sqr(mx - x) + sqr(my - y) <= sqr(Radius + Gear^.Radius + 2)) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	249	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	250	with cGear^ do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	251	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	252	dX:= Gear^.dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	253	dY:= Gear^.dY * _0_5;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	254	State:= State or gstMoving;
7767 d1ea9b3f543e damn nots nemo parents: 7756 diff changeset	255	if Kind = gtKnife then State:= State and (not gstCollision);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	256	Active:= true
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	257	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	258	DeleteCI(cGear);
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	259	exit(0);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	260	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	261	end
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	262	end;
69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	263
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	264	function TestCollisionYKick(Gear: PGear; Dir: LongInt): Word;
7756 b89bd0ffb8aa Try to prevent a situation where hogs embedded in other hogs/barrels/cleavers get stuck, by checking for gears overlapping on Y nemo parents: 7754 diff changeset	265	var x, y, mx, my, myr, i: LongInt;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	266	pixel: Word;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	267	begin
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	268	pixel:= 0;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	269	y:= hwRound(Gear^.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	270	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	271	y:= y - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	272	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	273	y:= y + Gear^.Radius;
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: 6986 diff changeset	274
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1528 diff changeset	275	if (y and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	276	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	277	x:= hwRound(Gear^.X) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	278	i:= x + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	279	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	280	if (x and LAND_WIDTH_MASK) = 0 then
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	281	if Land[y, x] > 0 then
11077 1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	282	begin
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	283	if Land[y, x] and Gear^.CollisionMask > 255 then
953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	284	exit(Land[y, x] and Gear^.CollisionMask)
11077 1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	285	else // if Land[y, x] <> 0 then
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	286	pixel:= Land[y, x] and Gear^.CollisionMask;
11077 1fb80cd8ba7b small code cleanup sheepluva parents: 11046 diff changeset	287	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	288	inc(x)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	289	until (x > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	290	end;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	291	TestCollisionYKick:= pixel;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	292
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	293	if pixel <> 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	294	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	295	if hwAbs(Gear^.dY) < cHHKick 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: 6986 diff changeset	296	exit;
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: 6986 diff changeset	297	if (Gear^.State and gstHHJumping <> 0) and (not Gear^.dY.isNegative) and (Gear^.dY < _0_4) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	298	exit;
967 8be3938d73c2 Don't let jumping hedgehog to move others unc0rr parents: 906 diff changeset	299
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	300	mx:= hwRound(Gear^.X);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	301	my:= hwRound(Gear^.Y);
7756 b89bd0ffb8aa Try to prevent a situation where hogs embedded in other hogs/barrels/cleavers get stuck, by checking for gears overlapping on Y nemo parents: 7754 diff changeset	302	myr:= my+Gear^.Radius;
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	303
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	304	for i:= 0 to Pred(Count) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	305	with cinfos[i] do
9305 8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	306	if (Gear <> cGear) and
8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	307	((myr > y) xor (Dir > 0)) and
8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	308	(Gear^.State and gstNotKickable = 0) and
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	309	(cGear^.Kind in [gtHedgehog, gtMine, gtKnife, gtExplosives]) and
9305 8e5140875ab5 bug #668 + reorder conditions for kick slightly, to call the math last nemo parents: 9291 diff changeset	310	(sqr(mx - x) + sqr(my - y) <= sqr(Radius + Gear^.Radius + 2)) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	311	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	312	with cGear^ do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	313	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	314	if (Kind <> gtExplosives) or ((State and gsttmpflag) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	315	dX:= Gear^.dX * _0_5;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	316	dY:= Gear^.dY;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	317	State:= State or gstMoving;
7767 d1ea9b3f543e damn nots nemo parents: 7756 diff changeset	318	if Kind = gtKnife then State:= State and (not gstCollision);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	319	Active:= true
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	320	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	321	DeleteCI(cGear);
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	322	exit(0)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	323	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	324	end
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	325	end;
69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 511 diff changeset	326
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	327	function TestCollisionXwithXYShift(Gear: PGear; ShiftX: hwFloat; ShiftY: LongInt; Dir: LongInt): Word; inline;
6986 409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	328	begin
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	329	TestCollisionXwithXYShift:= TestCollisionXwithXYShift(Gear, ShiftX, ShiftY, Dir, true);
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	330	end;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	331
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	332	function TestCollisionXwithXYShift(Gear: PGear; ShiftX: hwFloat; ShiftY: LongInt; Dir: LongInt; withGear: boolean): Word;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	333	begin
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	334	Gear^.X:= Gear^.X + ShiftX;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	335	Gear^.Y:= Gear^.Y + int2hwFloat(ShiftY);
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	336	if withGear then
5750 6bbf7aee2cdf Reenable a bunch of old portal play stuff, like dropping grenade into portal on hog, jumping through portal w/ hog on other end, collecting crate w/ portal etc. Also add cooldown to cake/portal interaction. It may still not do what you expect, but it probably shouldn't spin in place. nemo parents: 5572 diff changeset	337	TestCollisionXwithXYShift:= TestCollisionXwithGear(Gear, Dir)
6bbf7aee2cdf Reenable a bunch of old portal play stuff, like dropping grenade into portal on hog, jumping through portal w/ hog on other end, collecting crate w/ portal etc. Also add cooldown to cake/portal interaction. It may still not do what you expect, but it probably shouldn't spin in place. nemo parents: 5572 diff changeset	338	else TestCollisionXwithXYShift:= TestCollisionX(Gear, Dir);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	339	Gear^.X:= Gear^.X - ShiftX;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	340	Gear^.Y:= Gear^.Y - int2hwFloat(ShiftY)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	341	end;
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: 6986 diff changeset	342
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	343	function TestCollisionX(Gear: PGear; Dir: LongInt): Word;
4798 84fb1ff0a1c0 fix sticky rope issue sheepluva parents: 4705 diff changeset	344	var x, y, i: LongInt;
84fb1ff0a1c0 fix sticky rope issue sheepluva parents: 4705 diff changeset	345	begin
84fb1ff0a1c0 fix sticky rope issue sheepluva parents: 4705 diff changeset	346	x:= hwRound(Gear^.X);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	347	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	348	x:= x - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	349	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	350	x:= x + Gear^.Radius;
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: 6986 diff changeset	351
4798 84fb1ff0a1c0 fix sticky rope issue sheepluva parents: 4705 diff changeset	352	if (x and LAND_WIDTH_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	353	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	354	y:= hwRound(Gear^.Y) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	355	i:= y + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	356	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	357	if (y and LAND_HEIGHT_MASK) = 0 then
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	358	if Land[y, x] and Gear^.CollisionMask > 255 then
953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	359	exit(Land[y, x] and Gear^.CollisionMask);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	360	inc(y)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	361	until (y > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	362	end;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	363	TestCollisionX:= 0
4798 84fb1ff0a1c0 fix sticky rope issue sheepluva parents: 4705 diff changeset	364	end;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	365
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	366	function TestCollisionY(Gear: PGear; Dir: LongInt): Word;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 351 diff changeset	367	var x, y, i: LongInt;
68 cbb93eb90304 Collision-related stuff unc0rr parents: 64 diff changeset	368	begin
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 183 diff changeset	369	y:= hwRound(Gear^.Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	370	if Dir < 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	371	y:= y - Gear^.Radius
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	372	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	373	y:= y + Gear^.Radius;
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: 6986 diff changeset	374
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1528 diff changeset	375	if (y and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	376	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	377	x:= hwRound(Gear^.X) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	378	i:= x + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	379	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	380	if (x and LAND_WIDTH_MASK) = 0 then
9731 953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	381	if Land[y, x] and Gear^.CollisionMask > 255 then
953197ac43d8 Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore nemo parents: 9708 diff changeset	382	exit(Land[y, x] and Gear^.CollisionMask);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	383	inc(x)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	384	until (x > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	385	end;
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	386	TestCollisionY:= 0
68 cbb93eb90304 Collision-related stuff unc0rr parents: 64 diff changeset	387	end;
cbb93eb90304 Collision-related stuff unc0rr parents: 64 diff changeset	388
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	389	function TestCollisionYwithXYShift(Gear: PGear; ShiftX, ShiftY: LongInt; Dir: LongInt): Word; inline;
6986 409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	390	begin
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	391	TestCollisionYwithXYShift:= TestCollisionYwithXYShift(Gear, ShiftX, ShiftY, Dir, true);
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	392	end;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser) koda parents: 6700 diff changeset	393
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	394	function TestCollisionYwithXYShift(Gear: PGear; ShiftX, ShiftY: LongInt; Dir: LongInt; withGear: boolean): Word;
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	395	begin
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	396	Gear^.X:= Gear^.X + int2hwFloat(ShiftX);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	397	Gear^.Y:= Gear^.Y + int2hwFloat(ShiftY);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	398
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	399	if withGear then
9706 5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline. nemo parents: 9305 diff changeset	400	TestCollisionYwithXYShift:= TestCollisionYwithGear(Gear, Dir)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	401	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	402	TestCollisionYwithXYShift:= TestCollisionY(Gear, Dir);
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	403
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	404	Gear^.X:= Gear^.X - int2hwFloat(ShiftX);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 393 diff changeset	405	Gear^.Y:= Gear^.Y - int2hwFloat(ShiftY)
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	406	end;
bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	407
10818 f642a28cab0c Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget nemo parents: 10635 diff changeset	408	function TestRectangleForObstacle(x1, y1, x2, y2: LongInt; landOnly: boolean): boolean;
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	409	var x, y: LongInt;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	410	TestWord: LongWord;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	411	begin
10818 f642a28cab0c Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget nemo parents: 10635 diff changeset	412	TestRectangleForObstacle:= true;
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: 6986 diff changeset	413
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	414	if landOnly then
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	415	TestWord:= 255
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	416	else
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	417	TestWord:= 0;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	418
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	419	if x1 > x2 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: 6986 diff changeset	420	begin
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	421	x := x1;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	422	x1 := x2;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	423	x2 := x;
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: 6986 diff changeset	424	end;
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	425
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	426	if y1 > y2 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: 6986 diff changeset	427	begin
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	428	y := y1;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	429	y1 := y2;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	430	y2 := y;
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: 6986 diff changeset	431	end;
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	432
5919 f737843dd331 TestRectForObstacle: areas outside map borders are not passable sheepluva parents: 5896 diff changeset	433	if (hasBorder and ((y1 < 0) or (x1 < 0) or (x2 > LAND_WIDTH))) 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: 6986 diff changeset	434	exit;
5919 f737843dd331 TestRectForObstacle: areas outside map borders are not passable sheepluva parents: 5896 diff changeset	435
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	436	for y := y1 to y2 do
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	437	for x := x1 to x2 do
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: 6986 diff changeset	438	if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) and (Land[y, x] > TestWord) then
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6986 diff changeset	439	exit;
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	440
10818 f642a28cab0c Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget nemo parents: 10635 diff changeset	441	TestRectangleForObstacle:= false
5896 9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	442	end;
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	443
9ce1cf4e5a32 lua: boolean TestRectForObstacle(x1, y1, x2, y2, landOnly) sheepluva parents: 5834 diff changeset	444	function CalcSlopeTangent(Gear: PGear; collisionX, collisionY: LongInt; var outDeltaX, outDeltaY: LongInt; TestWord: LongWord): boolean;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	445	var ldx, ldy, rdx, rdy: LongInt;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	446	i, j, k, mx, my, li, ri, jfr, jto, tmpo : ShortInt;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	447	tmpx, tmpy: LongWord;
3569 27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	448	dx, dy, s: hwFloat;
6453 11c578d30bd3 Countless imporvements to the parser and countless help to the parser in sources. unc0rr parents: 6279 diff changeset	449	offset: array[0..7,0..1] of ShortInt;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	450	isColl: Boolean;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	451
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	452	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: 6986 diff changeset	453	CalcSlopeTangent:= false;
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: 6986 diff changeset	454
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	455	dx:= Gear^.dX;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	456	dy:= Gear^.dY;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	457
3569 27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	458	// we start searching from the direction the gear came from
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	459	if (dx.QWordValue > _0_995.QWordValue )
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	460	or (dy.QWordValue > _0_995.QWordValue ) then
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	461	begin // scale
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	462	s := _0_995 / Distance(dx,dy);
3569 27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	463	dx := s * dx;
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	464	dy := s * dy;
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	465	end;
27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	466
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	467	mx:= hwRound(Gear^.X-dx) - hwRound(Gear^.X);
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	468	my:= hwRound(Gear^.Y-dy) - hwRound(Gear^.Y);
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	469
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	470	li:= -1;
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	471	ri:= -1;
3569 27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	472
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	473	// go around collision pixel, checking for first/last collisions
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	474	// this will determinate what angles will be tried to crawl along
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	475	for i:= 0 to 7 do
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	476	begin
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	477	offset[i,0]:= mx;
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	478	offset[i,1]:= my;
3569 27b0ec683572 portal / slope detection: sheepluva parents: 3474 diff changeset	479
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	480	// multiplicator k tries to skip small pixels/gaps when possible
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	481	for k:= 4 downto 1 do
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	482	begin
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	483	tmpx:= collisionX + k * mx;
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	484	tmpy:= collisionY + k * my;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	485
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	486	if (((tmpy) and LAND_HEIGHT_MASK) = 0) and (((tmpx) and LAND_WIDTH_MASK) = 0) then
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	487	if (Land[tmpy,tmpx] > TestWord) then
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	488	begin
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	489	// remember the index belonging to the first and last collision (if in 1st half)
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	490	if (i <> 0) then
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	491	begin
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	492	if (ri = -1) then
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	493	ri:= i
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	494	else
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	495	li:= i;
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	496	end;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	497	end;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	498	end;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	499
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	500	if i = 7 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	501	break;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	502
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	503	// prepare offset for next check (clockwise)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	504	if (mx = -1) and (my <> -1) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	505	my:= my - 1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	506	else if (my = -1) and (mx <> 1) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	507	mx:= mx + 1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	508	else if (mx = 1) and (my <> 1) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	509	my:= my + 1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	510	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	511	mx:= mx - 1;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	512
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	513	end;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	514
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	515	ldx:= collisionX;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	516	ldy:= collisionY;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	517	rdx:= collisionX;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	518	rdy:= collisionY;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	519
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	520	// edge-crawl
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	521	for i:= 0 to 8 do
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	522	begin
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	523	// using mx,my as temporary value buffer here
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3609 diff changeset	524
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	525	jfr:= 8+li+1;
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	526	jto:= 8+li-1;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	527
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	528	isColl:= false;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	529	for j:= jfr downto jto do
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	530	begin
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	531	tmpo:= j mod 8;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	532	// multiplicator k tries to skip small pixels/gaps when possible
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	533	for k:= 3 downto 1 do
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	534	begin
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	535	tmpx:= ldx + k * offset[tmpo,0];
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	536	tmpy:= ldy + k * offset[tmpo,1];
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	537	if (((tmpy) and LAND_HEIGHT_MASK) = 0) and (((tmpx) and LAND_WIDTH_MASK) = 0)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	538	and (Land[tmpy,tmpx] > TestWord) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	539	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	540	ldx:= tmpx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	541	ldy:= tmpy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	542	isColl:= true;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	543	break;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	544	end;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	545	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	546	if isColl then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	547	break;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	548	end;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	549
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	550	jfr:= 8+ri-1;
56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	551	jto:= 8+ri+1;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	552
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	553	isColl:= false;
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	554	for j:= jfr to jto do
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	555	begin
3408 56e636b83cb4 tweak land angle detection/portal a bit sheepluva parents: 3407 diff changeset	556	tmpo:= j mod 8;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	557	for k:= 3 downto 1 do
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	558	begin
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	559	tmpx:= rdx + k * offset[tmpo,0];
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	560	tmpy:= rdy + k * offset[tmpo,1];
0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	561	if (((tmpy) and LAND_HEIGHT_MASK) = 0) and (((tmpx) and LAND_WIDTH_MASK) = 0)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	562	and (Land[tmpy,tmpx] > TestWord) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	563	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	564	rdx:= tmpx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	565	rdy:= tmpy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	566	isColl:= true;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	567	break;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	568	end;
6123 0cb751caf0ac make slope calcs skip small gaps sheepluva parents: 6081 diff changeset	569	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	570	if isColl then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	571	break;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	572	end;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	573	end;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	574
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	575	ldx:= rdx - ldx;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	576	ldy:= rdy - ldy;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	577
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	578	if ((ldx = 0) and (ldy = 0)) 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: 6986 diff changeset	579	exit;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	580
3414 b2f3bb44777e some portal changes, warning: no loop prevention yet, note: entry angle not preserved yet sheepluva parents: 3411 diff changeset	581	outDeltaX:= ldx;
b2f3bb44777e some portal changes, warning: no loop prevention yet, note: entry angle not preserved yet sheepluva parents: 3411 diff changeset	582	outDeltaY:= ldy;
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: 6986 diff changeset	583	CalcSlopeTangent:= true;
3401 d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	584	end;
d5d31d16eccc add a part of my landslide vector collision and use if for the portal gun DirAngle, not flawless yet sheepluva parents: 3236 diff changeset	585
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	586	function CalcSlopeNearGear(Gear: PGear; dirX, dirY: LongInt): hwFloat;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	587	var dx, dy: hwFloat;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	588	collX, collY, i, y, x, gx, gy, sdx, sdy: LongInt;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	589	isColl, bSucc: Boolean;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	590	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	591
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9950 diff changeset	592	if dirY <> 0 then
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	593	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	594	y:= hwRound(Gear^.Y) + Gear^.Radius * dirY;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	595	gx:= hwRound(Gear^.X);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	596	collX := gx;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	597	isColl:= false;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	598
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	599	if (y and LAND_HEIGHT_MASK) = 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	600	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	601	x:= hwRound(Gear^.X) - Gear^.Radius + 1;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	602	i:= x + Gear^.Radius * 2 - 2;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	603	repeat
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	604	if (x and LAND_WIDTH_MASK) = 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	605	if Land[y, x] <> 0 then
7767 d1ea9b3f543e damn nots nemo parents: 7756 diff changeset	606	if (not isColl) or (abs(x-gx) < abs(collX-gx)) then
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	607	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	608	isColl:= true;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	609	collX := x;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	610	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	611	inc(x)
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	612	until (x > i);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	613	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	614	end
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	615	else
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	616	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	617	x:= hwRound(Gear^.X) + Gear^.Radius * dirX;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	618	gy:= hwRound(Gear^.Y);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	619	collY := gy;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	620	isColl:= false;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	621
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	622	if (x and LAND_WIDTH_MASK) = 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	623	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	624	y:= hwRound(Gear^.Y) - Gear^.Radius + 1;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	625	i:= y + Gear^.Radius * 2 - 2;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	626	repeat
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	627	if (y and LAND_HEIGHT_MASK) = 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	628	if Land[y, x] <> 0 then
7767 d1ea9b3f543e damn nots nemo parents: 7756 diff changeset	629	if (not isColl) or (abs(y-gy) < abs(collY-gy)) then
7754 e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	630	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	631	isColl:= true;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	632	collY := y;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	633	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	634	inc(y)
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	635	until (y > i);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	636	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	637	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	638
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	639	if isColl then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	640	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	641	// save original dx/dy
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	642	dx := Gear^.dX;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	643	dy := Gear^.dY;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	644
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	645	if dirY <> 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	646	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	647	Gear^.dX.QWordValue:= 0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	648	Gear^.dX.isNegative:= (collX >= gx);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	649	Gear^.dY:= _1*dirY
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	650	end
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	651	else
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	652	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	653	Gear^.dY.QWordValue:= 0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	654	Gear^.dY.isNegative:= (collY >= gy);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	655	Gear^.dX:= _1*dirX
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	656	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	657
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	658	sdx:= 0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	659	sdy:= 0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	660	if dirY <> 0 then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	661	bSucc := CalcSlopeTangent(Gear, collX, y, sdx, sdy, 0)
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	662	else bSucc := CalcSlopeTangent(Gear, x, collY, sdx, sdy, 0);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	663
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	664	// restore original dx/dy
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	665	Gear^.dX := dx;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	666	Gear^.dY := dy;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	667
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	668	if bSucc and ((sdx <> 0) or (sdy <> 0)) then
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	669	begin
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	670	dx := int2hwFloat(sdy) / (abs(sdx) + abs(sdy));
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	671	dx.isNegative := (sdx * sdy) < 0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	672	exit (dx);
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	673	end
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	674	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	675
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	676	CalcSlopeNearGear := _0;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	677	end;
e81dc9bef8b8 First pass at cleaver. nemo parents: 7489 diff changeset	678
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	679	function CalcSlopeBelowGear(Gear: PGear): hwFloat;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	680	var dx, dy: hwFloat;
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	681	collX, i, y, x, gx, sdx, sdy: LongInt;
6453 11c578d30bd3 Countless imporvements to the parser and countless help to the parser in sources. unc0rr parents: 6279 diff changeset	682	isColl, bSucc: Boolean;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	683	begin
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	684
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	685
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	686	y:= hwRound(Gear^.Y) + Gear^.Radius;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	687	gx:= hwRound(Gear^.X);
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	688	collX := gx;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	689	isColl:= false;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	690
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	691	if (y and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	692	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	693	x:= hwRound(Gear^.X) - Gear^.Radius + 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	694	i:= x + Gear^.Radius * 2 - 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	695	repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	696	if (x and LAND_WIDTH_MASK) = 0 then
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	697	if Land[y, x] > 255 then
7767 d1ea9b3f543e damn nots nemo parents: 7756 diff changeset	698	if (not isColl) or (abs(x-gx) < abs(collX-gx)) then
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	699	begin
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	700	isColl:= true;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	701	collX := x;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	702	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	703	inc(x)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	704	until (x > i);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6543 diff changeset	705	end;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	706
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	707	if isColl then
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	708	begin
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	709	// save original dx/dy
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	710	dx := Gear^.dX;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	711	dy := Gear^.dY;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	712
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	713	Gear^.dX.QWordValue:= 0;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	714	Gear^.dX.isNegative:= (collX >= gx);
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	715	Gear^.dY:= _1;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	716
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	717	sdx:= 0;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	718	sdy:= 0;
6453 11c578d30bd3 Countless imporvements to the parser and countless help to the parser in sources. unc0rr parents: 6279 diff changeset	719	bSucc := CalcSlopeTangent(Gear, collX, y, sdx, sdy, 255);
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	720
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	721	// restore original dx/dy
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	722	Gear^.dX := dx;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	723	Gear^.dY := dy;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	724
6453 11c578d30bd3 Countless imporvements to the parser and countless help to the parser in sources. unc0rr parents: 6279 diff changeset	725	if bSucc and (sdx <> 0) and (sdy <> 0) then
6279 7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	726	begin
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	727	dx := int2hwFloat(sdy) / (abs(sdx) + abs(sdy));
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	728	dx.isNegative := (sdx * sdy) < 0;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	729	exit (dx);
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	730	end;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	731	end;
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	732
7f724835ea57 I hope this helps... sheepluva parents: 6124 diff changeset	733	CalcSlopeBelowGear := _0;
6124 bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	734	end;
bee90df26109 something for nemo to play around with sheepluva parents: 6123 diff changeset	735
3038 4e48c276a468 In pascal unit is a namespace unc0rr parents: 2948 diff changeset	736	procedure initModule;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	737	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2716 diff changeset	738	Count:= 0;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	739	end;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	740
3038 4e48c276a468 In pascal unit is a namespace unc0rr parents: 2948 diff changeset	741	procedure freeModule;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	742	begin
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	743
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	744	end;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2630 diff changeset	745
4 bcbd7adb4e4b - set svn:eol-style to native unc0rr parents: 1 diff changeset	746	end.

author	antonc27 <antonc27@mail.ru>
	Fri, 30 Oct 2015 01:31:32 +0100
branch	ios-revival
changeset 11256	148bb90d7e32
parent 11077	1fb80cd8ba7b
child 11532	bf86c6cb9341
permissions	-rw-r--r--