sheepy-clone: hedgewars/uFloat.pas@4feced261c68 (annotated)

351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	1	(*
1066 1f1b3686a2b0 Update copyright headers a bit unc0rr parents: 967 diff changeset	2	* Hedgewars, a free turn based strategy game
9998 736015b847e3 update copyright to 2014 sheepluva parents: 9080 diff changeset	3	* Copyright (c) 2004-2014 Andrey Korotaev <unC0Rr@gmail.com>
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	4	*
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	5	* This program is free software; you can redistribute it and/or modify
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	6	* it under the terms of the GNU General Public License as published by
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	7	* the Free Software Foundation; version 2 of the License
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	8	*
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	9	* This program is distributed in the hope that it will be useful,
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	12	* GNU General Public License for more details.
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	13	*
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	14	* You should have received a copy of the GNU General Public License
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	15	* along with this program; if not, write to the Free Software
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	17	*)
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 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
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	21	unit uFloat;
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	22	(*
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	23	* This unit provides a custom data type, hwFloat.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	24	*
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	25	* hwFloat represents a floating point number - the value and operations
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	26	* of this numbers are independent from the hardware architecture
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	27	* the game runs on.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	28	*
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	29	* This is important for calculations that affect the course of the game
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	30	* and would lead to different results if based on a hardware dependent
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	31	* data type.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	32	*
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	33	* Note: Not all comparisons are implemented.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	34	*
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	35	* Note: Below you'll find a list of hwFloat constants:
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	36	* E.g. _1 is an hwFloat with value 1.0, and -_0_9 is -0.9
5124 84267f79879b comments sheepluva parents: 5122 diff changeset	37	* Use and extend the list if needed, rather than using int2hwFloat()
84267f79879b comments sheepluva parents: 5122 diff changeset	38	* with integer constants.
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	39	*)
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	40	interface
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	41
2599 c7153d2348f3 move compiler directives to standard pascal koda parents: 2587 diff changeset	42	{$IFDEF ENDIAN_LITTLE}
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	43	type hwFloat = record
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	44	isNegative: boolean;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	45	case byte of
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	46	0: (Frac, Round: Longword);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	47	1: (QWordValue : QWord);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	48	end;
2599 c7153d2348f3 move compiler directives to standard pascal koda parents: 2587 diff changeset	49	{$ELSE}
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	50	type hwFloat = record
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	51	isNegative: boolean;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	52	case byte of
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	53	0: (Round, Frac: Longword);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	54	1: (QWordValue : QWord);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	55	end;
2599 c7153d2348f3 move compiler directives to standard pascal koda parents: 2587 diff changeset	56	{$ENDIF}
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	57
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	58	// Returns an hwFloat that represents the value of integer parameter i
3599 715a43602da8 sheepluva's inline patch, fix a crash in overlay koda parents: 3591 diff changeset	59	function int2hwFloat (const i: LongInt) : hwFloat; inline;
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5124 diff changeset	60	function hwFloat2Float (const i: hwFloat) : extended; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	61
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	62	// The implemented operators
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	63
6415 af2047bb4f70 GSoC 2011: Android port - merged mainstream koda parents: 6328 diff changeset	64	operator = (const z1, z2: hwFloat) z : boolean; inline;
7043 7c080e5ac8d0 Some work to make more units compile after conversion to c unc0rr parents: 7042 diff changeset	65	{$IFDEF PAS2C}
7042 de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	66	operator <> (const z1, z2: hwFloat) z : boolean; inline;
7043 7c080e5ac8d0 Some work to make more units compile after conversion to c unc0rr parents: 7042 diff changeset	67	{$ENDIF}
3599 715a43602da8 sheepluva's inline patch, fix a crash in overlay koda parents: 3591 diff changeset	68	operator + (const z1, z2: hwFloat) z : hwFloat; inline;
715a43602da8 sheepluva's inline patch, fix a crash in overlay koda parents: 3591 diff changeset	69	operator - (const z1, z2: hwFloat) z : hwFloat; inline;
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	70	operator - (const z1: hwFloat) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	71
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	72	operator * (const z1, z2: hwFloat) z : hwFloat; inline;
3599 715a43602da8 sheepluva's inline patch, fix a crash in overlay koda parents: 3591 diff changeset	73	operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	74	operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline;
9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	75	operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	76
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	77	operator < (const z1, z2: hwFloat) b : boolean; inline;
9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	78	operator > (const z1, z2: hwFloat) b : boolean; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	79
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	80
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	81	// Various functions for hwFloat (some are inlined in the resulting code for better performance)
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	82
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	83	function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	84	function hwRound(const t: hwFloat): LongInt; inline; // Does NOT really round but returns the integer representation of the hwFloat without fractional digits. (-_0_9 -> -0, _1_5 -> _1)
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	85	function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	86	function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t.
6785 a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	87	function hwPow(const t: hwFloat; p: LongWord): hwFloat; inline; // Returns the power of the value
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	88	function hwSqrt1(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	89	function hwSqrt(const x: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	90	function Distance(const dx, dy: hwFloat): hwFloat; // Returns the distance between two points in 2-dimensional space, of which the parameters are the horizontal and vertical distance.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	91	function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters.
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	92	function AngleSin(const Angle: Longword): hwFloat;
270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	93	function AngleCos(const Angle: Longword): hwFloat;
7714 981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	94	function vector2Angle(const x, y: hwFloat): LongInt;
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	95	function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum.
9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	96	function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r.
6879 f44042ba755c Simplify converter's life unc0rr parents: 6785 diff changeset	97	function hwSignf(r: real): LongInt; inline; // Returns an integer with value 1 and sign of parameter r.
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	98	function isZero(const z: hwFloat): boolean; inline;
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	99
611 8cf6d27cec86 Fix warnings unc0rr parents: 543 diff changeset	100	{$WARNINGS OFF}
5122 9b0513507ba8 some more comments yawns sheepluva parents: 4976 diff changeset	101	// some hwFloat constants
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	102	const _1div1024: hwFloat = (isNegative: false; QWordValue: 4194304);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	103	_1div10000: hwFloat = (isNegative: false; QWordValue: 429496);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	104	_1div50000: hwFloat = (isNegative: false; QWordValue: 85899);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	105	_1div100000: hwFloat = (isNegative: false; QWordValue: 42950);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	106	_1div3: hwFloat = (isNegative: false; QWordValue: 1431655766);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	107	hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	108	_0_000004: hwFloat = (isNegative: false; QWordValue: 17179);
3591 c447d5218f6f bee: sheepluva parents: 3584 diff changeset	109	_0_000064: hwFloat = (isNegative: false; QWordValue: 274878);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	110	_0_0002: hwFloat = (isNegative: false; QWordValue: 858993);
1586 2c6f1d1f43c1 Adjust flame parameters to produce more damage unc0rr parents: 1433 diff changeset	111	_0_0005: hwFloat = (isNegative: false; QWordValue: 2147484);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	112	_0_001: hwFloat = (isNegative: false; QWordValue: 4294967);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	113	_0_003: hwFloat = (isNegative: false; QWordValue: 12884902);
7663 16e1422aee8e More precision unc0rr parents: 7657 diff changeset	114	_0_0032: hwFloat = (isNegative: false; QWordValue: 13743895);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	115	_0_004: hwFloat = (isNegative: false; QWordValue: 17179869);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	116	_0_005: hwFloat = (isNegative: false; QWordValue: 21474836);
3428 46a2694867bc portal: sheepluva parents: 3422 diff changeset	117	_0_008: hwFloat = (isNegative: false; QWordValue: 34359738);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	118	_0_01: hwFloat = (isNegative: false; QWordValue: 42949673);
7593 b966e2d833f2 An attempt to run main rope code only every 8th tick: unc0rr parents: 7515 diff changeset	119	_0_0128: hwFloat = (isNegative: false; QWordValue: 54975581);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	120	_0_02: hwFloat = (isNegative: false; QWordValue: 85899345);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	121	_0_03: hwFloat = (isNegative: false; QWordValue: 128849018);
6295 5b2b304a91ec Due to the small values and friction, halve the step in low gravity, instead of the value nemo parents: 5843 diff changeset	122	_0_07: hwFloat = (isNegative: false; QWordValue: 300647710);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	123	_0_08: hwFloat = (isNegative: false; QWordValue: 343597383);
365 a26cec847dd7 - New land generator feature: islands in the sky unc0rr parents: 358 diff changeset	124	_0_1: hwFloat = (isNegative: false; QWordValue: 429496730);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	125	_0_15: hwFloat = (isNegative: false; QWordValue: 644245094);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	126	_0_2: hwFloat = (isNegative: false; QWordValue: 858993459);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	127	_0_25: hwFloat = (isNegative: false; QWordValue: 1073741824);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	128	_0_3: hwFloat = (isNegative: false; QWordValue: 1288490189);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	129	_0_35: hwFloat = (isNegative: false; QWordValue: 1503238553);
2784 1a2e3c7c6a46 King health proportional to team size nemo parents: 2630 diff changeset	130	_0_375: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 8);
835 6f567934cc44 Automatically use parachute when vertical speed is high enough unc0rr parents: 745 diff changeset	131	_0_39: hwFloat = (isNegative: false; QWordValue: 1675037245);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	132	_0_4: hwFloat = (isNegative: false; QWordValue: 1717986918);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	133	_0_45: hwFloat = (isNegative: false; QWordValue: 1932735283);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	134	_0_5: hwFloat = (isNegative: false; QWordValue: 2147483648);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	135	_0_55: hwFloat = (isNegative: false; QWordValue: 2362232012);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	136	_0_6: hwFloat = (isNegative: false; QWordValue: 2576980377);
3583 13818670ad9e rope: tiny optimisation sheepluva parents: 3428 diff changeset	137	_0_64: hwFloat = (isNegative: false; QWordValue: 2748779064);
358 236bbd12d4d9 - New Land Generator unc0rr parents: 357 diff changeset	138	_0_7: hwFloat = (isNegative: false; QWordValue: 3006477107);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	139	_0_8: hwFloat = (isNegative: false; QWordValue: 3435973837);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	140	_0_84: hwFloat = (isNegative: false; QWordValue: 3607772528);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	141	_0_87: hwFloat = (isNegative: false; QWordValue: 3736621547);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	142	_0_9: hwFloat = (isNegative: false; QWordValue: 3865470566);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	143	_0_93: hwFloat = (isNegative: false; QWordValue: 3994319585);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	144	_0_96: hwFloat = (isNegative: false; QWordValue: 4123168604);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	145	_0_995: hwFloat = (isNegative: false; QWordValue: 4273492459);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	146	_0_999: hwFloat = (isNegative: false; QWordValue: 4290672328);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	147	_0: hwFloat = (isNegative: false; QWordValue: 0);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	148	_1: hwFloat = (isNegative: false; QWordValue: 4294967296);
9968 7fb2f35bdd5b Fix two desync causes unc0rr parents: 9127 diff changeset	149	_1_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6 div 5 + 1);
513 69e06d710d46 Moving hedgehog could get another hedgehog moving forward unc0rr parents: 498 diff changeset	150	_1_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 2);
7593 b966e2d833f2 An attempt to run main rope code only every 8th tick: unc0rr parents: 7515 diff changeset	151	_1_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 8 div 5);
3584 7c05f2e0a8b5 rope: another small optimization sheepluva parents: 3583 diff changeset	152	_1_9: hwFloat = (isNegative: false; QWordValue: 8160437862);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	153	_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2);
7593 b966e2d833f2 An attempt to run main rope code only every 8th tick: unc0rr parents: 7515 diff changeset	154	_2_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12 div 5);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	155	_3: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3);
9970 88353250ad7d Fix these too unc0rr parents: 9968 diff changeset	156	_3_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16 div 5);
6785 a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	157	_PI: hwFloat = (isNegative: false; QWordValue: 13493037704);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	158	_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4);
6498 5678806aafca Some tiny optimizations unc0rr parents: 6443 diff changeset	159	_4_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 9 div 2);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	160	_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 5);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	161	_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6);
9970 88353250ad7d Fix these too unc0rr parents: 9968 diff changeset	162	_6_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 32 div 5);
7593 b966e2d833f2 An attempt to run main rope code only every 8th tick: unc0rr parents: 7515 diff changeset	163	_7: hwFloat = (isNegative: false; QWordValue: 4294967296 * 7);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	164	_10: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10);
3422 41ae3c48faa0 * some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted sheepluva parents: 3407 diff changeset	165	_12: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	166	_16: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	167	_19: hwFloat = (isNegative: false; QWordValue: 4294967296 * 19);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	168	_20: hwFloat = (isNegative: false; QWordValue: 4294967296 * 20);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	169	_25: hwFloat = (isNegative: false; QWordValue: 4294967296 * 25);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	170	_30: hwFloat = (isNegative: false; QWordValue: 4294967296 * 30);
2955 fb361d137524 Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40 nemo parents: 2948 diff changeset	171	_40: hwFloat = (isNegative: false; QWordValue: 4294967296 * 40);
7594 5f03595335e6 fromdos + fix end of turn velocity nemo parents: 7593 diff changeset	172	_41: hwFloat = (isNegative: false; QWordValue: 4294967296 * 41);
7593 b966e2d833f2 An attempt to run main rope code only every 8th tick: unc0rr parents: 7515 diff changeset	173	_49: hwFloat = (isNegative: false; QWordValue: 4294967296 * 49);
3036 c6ba6531cb4b Make barrels a little more likely to blow up. 25% more damage in fall nemo parents: 2955 diff changeset	174	_50: hwFloat = (isNegative: false; QWordValue: 4294967296 * 50);
2933 02af54eb7e1e Experiment with barrels. Add rolling. nemo parents: 2905 diff changeset	175	_70: hwFloat = (isNegative: false; QWordValue: 4294967296 * 70);
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	176	_90: hwFloat = (isNegative: false; QWordValue: 4294967296 * 90);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	177	_128: hwFloat = (isNegative: false; QWordValue: 4294967296 * 128);
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	178	_180: hwFloat = (isNegative: false; QWordValue: 4294967296 * 180);
5319 51d8e4747876 bounce. tweak of values, remove friction modifier, move to weapon, to match timer behaviour nemo parents: 5192 diff changeset	179	_250: hwFloat = (isNegative: false; QWordValue: 4294967296 * 250);
1915 c357f5b55320 patch by nemo: unc0rr parents: 1753 diff changeset	180	_256: hwFloat = (isNegative: false; QWordValue: 4294967296 * 256);
1124 1636a3c7c061 - Airplane is higher unc0rr parents: 1066 diff changeset	181	_300: hwFloat = (isNegative: false; QWordValue: 4294967296 * 300);
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	182	_360: hwFloat = (isNegative: false; QWordValue: 4294967296 * 360);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	183	_450: hwFloat = (isNegative: false; QWordValue: 4294967296 * 450);
5319 51d8e4747876 bounce. tweak of values, remove friction modifier, move to weapon, to match timer behaviour nemo parents: 5192 diff changeset	184	_1000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1000);
611 8cf6d27cec86 Fix warnings unc0rr parents: 543 diff changeset	185	_1024: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1024);
8cf6d27cec86 Fix warnings unc0rr parents: 543 diff changeset	186	_2048: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2048);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1652 diff changeset	187	_4096: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4096);
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	188	_10000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10000);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	189
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	190	cLittle: hwFloat = (isNegative: false; QWordValue: 1);
967 8be3938d73c2 Don't let jumping hedgehog to move others unc0rr parents: 953 diff changeset	191	cHHKick: hwFloat = (isNegative: false; QWordValue: 42949673); // _0_01
611 8cf6d27cec86 Fix warnings unc0rr parents: 543 diff changeset	192	{$WARNINGS ON}
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	193
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	194	implementation
4415 941251bad467 SinTable.inc -> uSinTable.pas unc0rr parents: 4374 diff changeset	195	uses uSinTable;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	196
3599 715a43602da8 sheepluva's inline patch, fix a crash in overlay koda parents: 3591 diff changeset	197
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	198	function int2hwFloat (const i: LongInt) : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	199	begin
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	200	int2hwFloat.isNegative:= i < 0;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	201	int2hwFloat.Round:= abs(i);
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	202	int2hwFloat.Frac:= 0
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	203	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	204
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	205	function hwFloat2Float (const i: hwFloat) : extended; inline;
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5124 diff changeset	206	begin
7614 3ae60c8a15f2 Starting to rewrite uFloat routines to avoid QWordValue - in the interests of JS which may get uint64/int64 in the spec in the future but does not have it now. nemo parents: 7594 diff changeset	207	hwFloat2Float:= i.Frac / $100000000 + i.Round;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	208	if i.isNegative then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	209	hwFloat2Float:= -hwFloat2Float;
5151 cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5124 diff changeset	210	end;
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster. nemo parents: 5124 diff changeset	211
6415 af2047bb4f70 GSoC 2011: Android port - merged mainstream koda parents: 6328 diff changeset	212	operator = (const z1, z2: hwFloat) z : boolean; inline;
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	213	begin
5665 8805f3167058 fixed = operator in uFloat Xeli parents: 5599 diff changeset	214	z:= (z1.isNegative = z2.isNegative) and (z1.QWordValue = z2.QWordValue);
5599 2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	215	end;
2e4b90f33a83 aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen Xeli parents: 5319 diff changeset	216
7043 7c080e5ac8d0 Some work to make more units compile after conversion to c unc0rr parents: 7042 diff changeset	217	{$IFDEF PAS2C}
7042 de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	218	operator <> (const z1, z2: hwFloat) z : boolean; inline;
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	219	begin
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	220	z:= (z1.isNegative <> z2.isNegative) or (z1.QWordValue <> z2.QWordValue);
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	221	end;
7043 7c080e5ac8d0 Some work to make more units compile after conversion to c unc0rr parents: 7042 diff changeset	222	{$ENDIF}
7042 de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls unc0rr parents: 6879 diff changeset	223
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	224	operator + (const z1, z2: hwFloat) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	225	begin
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	226	if z1.isNegative = z2.isNegative then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	227	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	228	z.isNegative:= z1.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	229	z.QWordValue:= z1.QWordValue + z2.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	230	end
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	231	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	232	if z1.QWordValue > z2.QWordValue then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	233	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	234	z.isNegative:= z1.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	235	z.QWordValue:= z1.QWordValue - z2.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	236	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	237	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	238	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	239	z.isNegative:= z2.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	240	z.QWordValue:= z2.QWordValue - z1.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	241	end
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	242	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	243
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	244	operator - (const z1, z2: hwFloat) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	245	begin
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	246	if z1.isNegative = z2.isNegative then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	247	if z1.QWordValue > z2.QWordValue then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	248	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	249	z.isNegative:= z1.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	250	z.QWordValue:= z1.QWordValue - z2.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	251	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	252	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	253	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	254	z.isNegative:= not z2.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	255	z.QWordValue:= z2.QWordValue - z1.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	256	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	257	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	258	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	259	z.isNegative:= z1.isNegative;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	260	z.QWordValue:= z1.QWordValue + z2.QWordValue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	261	end
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	262	end;
7623 addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant. nemo parents: 7614 diff changeset	263
8924 13ac59499066 update 0.9.19 with dev branch koda parents: 8921 diff changeset	264	function isZero(const z: hwFloat): boolean; inline;
7623 addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant. nemo parents: 7614 diff changeset	265	begin
addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant. nemo parents: 7614 diff changeset	266	isZero := z.QWordValue = 0;
addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant. nemo parents: 7614 diff changeset	267	end;
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	268
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	269	operator < (const z1, z2: hwFloat) b : boolean; inline;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	270	begin
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	271	if z1.isNegative xor z2.isNegative then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	272	b:= z1.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	273	else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	274	if z1.QWordValue = z2.QWordValue then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	275	b:= false
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	276	else
8915 36e1574e989d Trivial optimization. Wonder if compiler was smart enough about it. unc0rr parents: 8905 diff changeset	277	b:= (z2.QWordValue < z1.QWordValue) = z1.isNegative
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	278	end;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	279
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	280	operator > (const z1, z2: hwFloat) b : boolean; inline;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	281	begin
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	282	if z1.isNegative xor z2.isNegative then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	283	b:= z2.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	284	else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	285	if z1.QWordValue = z2.QWordValue then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	286	b:= false
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	287	else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	288	b:= (z1.QWordValue > z2.QWordValue) <> z2.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	289	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	290
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	291	operator - (const z1: hwFloat) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	292	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	293	z:= z1;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	294	z.isNegative:= not z.isNegative
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	295	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	296
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	297
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	298	operator * (const z1, z2: hwFloat) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	299	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	300	z.isNegative:= z1.isNegative xor z2.isNegative;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	301	z.QWordValue:= QWord(z1.Round) * z2.Frac + QWord(z1.Frac) * z2.Round + ((QWord(z1.Frac) * z2.Frac) shr 32);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	302	z.Round:= z.Round + QWord(z1.Round) * z2.Round;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	303	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	304
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	305	operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	306	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	307	z.isNegative:= z1.isNegative xor (z2 < 0);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	308	z.QWordValue:= z1.QWordValue * abs(z2)
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	309	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	310
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	311	operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline;
8919 67214340fa53 lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613. unc0rr parents: 8917 diff changeset	312	var t: QWord;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	313	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	314	z.isNegative:= z1.isNegative xor z2.isNegative;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	315	z.Round:= z1.QWordValue div z2.QWordValue;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	316	t:= z1.QWordValue - z2.QWordValue * z.Round;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	317	z.Frac:= 0;
8916 71485c03a507 hwFloat division is ~1.6 times faster now unc0rr parents: 8915 diff changeset	318
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	319	if t <> 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	320	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	321	while ((t and $FF00000000000000) = 0) and ((z2.QWordValue and $FF00000000000000) = 0) do
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	322	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	323	t:= t shl 8;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	324	z2.QWordValue:= z2.QWordValue shl 8
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	325	end;
8921 e5db2a42e7e8 - Revert division hack nonsense unc0rr parents: 8919 diff changeset	326
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	327	if z2.Round > 0 then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	328	inc(z.QWordValue, t div z2.Round);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	329	end
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	330	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	331
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	332	operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	333	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	334	z.isNegative:= z1.isNegative xor (z2 < 0);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	335	z.QWordValue:= z1.QWordValue div abs(z2)
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	336	end;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	337
2905 f3c79f7193a9 Engine: smxx parents: 2784 diff changeset	338	function cstr(const z: hwFloat): shortstring;
f3c79f7193a9 Engine: smxx parents: 2784 diff changeset	339	var tmpstr: shortstring;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	340	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	341	str(z.Round, cstr);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	342	if z.Frac <> 0 then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	343	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	344	str(z.Frac / $100000000, tmpstr);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	345	delete(tmpstr, 1, 2);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	346	cstr:= cstr + '.' + copy(tmpstr, 1, 10)
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	347	end;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	348	if z.isNegative then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	349	cstr:= '-' + cstr
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	350	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	351
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	352	function hwRound(const t: hwFloat): LongInt;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	353	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	354	if t.isNegative then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	355	hwRound:= -(t.Round and $7FFFFFFF)
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	356	else
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	357	hwRound:= t.Round and $7FFFFFFF
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	358	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	359
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	360	function hwAbs(const t: hwFloat): hwFloat;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	361	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	362	hwAbs:= t;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	363	hwAbs.isNegative:= false
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	364	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	365
7624 03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle. nemo parents: 7623 diff changeset	366	function hwSqr(const t: hwFloat): hwFloat; inline;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	367	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	368	hwSqr.isNegative:= false;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	369	hwSqr.QWordValue:= ((QWord(t.Round) * t.Round) shl 32) + QWord(t.Round) * t.Frac * 2 + ((QWord(t.Frac) * t.Frac) shr 32);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	370	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	371
6785 a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	372	function hwPow(const t: hwFloat;p: LongWord): hwFloat;
a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	373	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	374	hwPow:= t;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	375	if p mod 2 = 0 then hwPow.isNegative:= false;
6785 a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	376
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	377	while p > 0 do
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	378	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	379	hwPow.QWordValue:= QWord(hwPow.Round) * t.Frac + QWord(hwPow.Frac) * t.Round + ((QWord(hwPow.Frac) * t.Frac) shr 32);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	380	dec(p)
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	381	end
6785 a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	382	end;
a8aa5984185f Allow RC plane to go through portals nemo parents: 6775 diff changeset	383
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	384	function hwSqrt1(const t: hwFloat): hwFloat;
7688 9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests unc0rr parents: 7663 diff changeset	385	const pwr = 8; // even value, feel free to adjust
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests unc0rr parents: 7663 diff changeset	386	rThreshold = 1 shl (pwr + 32);
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests unc0rr parents: 7663 diff changeset	387	lThreshold = 1 shl (pwr div 2 + 32);
738 d7f640e99b17 Ignore many files, created by build system unc0rr parents: 611 diff changeset	388	var l, r: QWord;
d7f640e99b17 Ignore many files, created by build system unc0rr parents: 611 diff changeset	389	c: hwFloat;
357 165a040e4cfa - Fix Blow Torch and Air Attack unc0rr parents: 355 diff changeset	390	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	391	hwSqrt1.isNegative:= false;
744 7a9663194767 - Remove debug unc0rr parents: 738 diff changeset	392
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	393	if t.Round = 0 then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	394	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	395	l:= t.QWordValue;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	396	r:= $100000000
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	397	end
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	398	else
7688 9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests unc0rr parents: 7663 diff changeset	399	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	400	if t.QWordValue > $FFFFFFFFFFFF then // t.Round > 65535.9999
7688 9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests unc0rr parents: 7663 diff changeset	401	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	402	l:= $10000000000; // 256
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	403	r:= $FFFFFFFFFFFF; // 65535.9999
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	404	end
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	405	else
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	406	if t.QWordValue >= rThreshold then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	407	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	408	l:= lThreshold;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	409	r:= $10000000000; // 256
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	410	end
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	411	else
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	412	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	413	l:= $100000000;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	414	r:= lThreshold;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	415	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	416	end;
744 7a9663194767 - Remove debug unc0rr parents: 738 diff changeset	417
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	418	repeat
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	419	c.QWordValue:= (l + r) shr 1;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	420	if hwSqr(c).QWordValue > t.QWordValue then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	421	r:= c.QWordValue
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	422	else
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	423	l:= c.QWordValue
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	424	until r - l <= 1;
744 7a9663194767 - Remove debug unc0rr parents: 738 diff changeset	425
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	426	hwSqrt1.QWordValue:= l
357 165a040e4cfa - Fix Blow Torch and Air Attack unc0rr parents: 355 diff changeset	427	end;
165a040e4cfa - Fix Blow Torch and Air Attack unc0rr parents: 355 diff changeset	428
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	429	function hwSqrt(const x: hwFloat): hwFloat;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	430	var r, t, s, q: QWord;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	431	i: integer;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	432	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	433	hwSqrt.isNegative:= false;
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	434
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	435	t:= $4000000000000000;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	436	r:= 0;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	437	q:= x.QWordValue;
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	438
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	439	for i:= 0 to 31 do
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	440	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	441	s:= r + t;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	442	r:= r shr 1;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	443	if s <= q then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	444	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	445	dec(q, s);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	446	inc(r, t);
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	447	end;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	448	t:= t shr 2;
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	449	end;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	450
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	451	hwSqrt.QWordValue:= r shl 16
8905 82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	452	end;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	453
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	454
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one! unc0rr parents: 8838 diff changeset	455
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	456	function Distance(const dx, dy: hwFloat): hwFloat;
8921 e5db2a42e7e8 - Revert division hack nonsense unc0rr parents: 8919 diff changeset	457	var r: QWord;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	458	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	459	r:= dx.QWordValue or dy.QWordValue;
8921 e5db2a42e7e8 - Revert division hack nonsense unc0rr parents: 8919 diff changeset	460
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	461	if r < $10000 then
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	462	begin
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	463	Distance.QWordValue:= r;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	464	Distance.isNegative:= false
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	465	end
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	466	else
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	467	Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy))
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	468	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	469
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	470	function DistanceI(const dx, dy: LongInt): hwFloat;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	471	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	472	DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy)))
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	473	end;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	474
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	475	function SignAs(const num, signum: hwFloat): hwFloat;
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	476	begin
10015 4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	477	SignAs.QWordValue:= num.QWordValue;
4feced261c68 partial merge of the webgl branch koda parents: 9998 9970 diff changeset	478	SignAs.isNegative:= signum.isNegative
498 9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	479	end;
9c8b385dc9a1 - Get rid of operator := to have GPC support unc0rr parents: 493 diff changeset	480
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 3929 diff changeset	481	function hwSign(r: hwFloat): LongInt;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 3929 diff changeset	482	begin
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 3929 diff changeset	483	// yes, we have negative zero for a reason
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	484	if r.isNegative then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	485	hwSign:= -1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	486	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	487	hwSign:= 1
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 3929 diff changeset	488	end;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 3929 diff changeset	489
6879 f44042ba755c Simplify converter's life unc0rr parents: 6785 diff changeset	490	function hwSignf(r: real): LongInt;
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6700 diff changeset	491	begin
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6700 diff changeset	492	if r < 0 then
6879 f44042ba755c Simplify converter's life unc0rr parents: 6785 diff changeset	493	hwSignf:= -1
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6700 diff changeset	494	else
6879 f44042ba755c Simplify converter's life unc0rr parents: 6785 diff changeset	495	hwSignf:= 1
6775 22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6700 diff changeset	496	end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball nemo parents: 6700 diff changeset	497
357 165a040e4cfa - Fix Blow Torch and Air Attack unc0rr parents: 355 diff changeset	498
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	499	function AngleSin(const Angle: Longword): hwFloat;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	500	begin
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	501	//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	502	AngleSin.isNegative:= false;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	503	if Angle < 1024 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	504	AngleSin.QWordValue:= SinTable[Angle]
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	505	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	506	AngleSin.QWordValue:= SinTable[2048 - Angle]
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	507	end;
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	508
515 270f10276d2e - Remove deprecated code unc0rr parents: 513 diff changeset	509	function AngleCos(const Angle: Longword): hwFloat;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	510	begin
3929 9a4bbc1f67a2 Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc nemo parents: 3599 diff changeset	511	//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true);
357 165a040e4cfa - Fix Blow Torch and Air Attack unc0rr parents: 355 diff changeset	512	AngleCos.isNegative:= Angle > 1024;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	513	if Angle < 1024 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	514	AngleCos.QWordValue:= SinTable[1024 - Angle]
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	515	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6498 diff changeset	516	AngleCos.QWordValue:= SinTable[Angle - 1024]
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	517	end;
7714 981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	518
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	519	function vector2Angle(const x, y: hwFloat): LongInt;
7715 8b653edac2a2 Shutup pas2c unc0rr parents: 7714 diff changeset	520	var d, nf: hwFloat;
7714 981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	521	l, r, c, oc: Longword;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	522	n: QWord;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	523	begin
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	524	d:= _1 / Distance(x, y);
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	525
7715 8b653edac2a2 Shutup pas2c unc0rr parents: 7714 diff changeset	526	nf:= y * d;
8b653edac2a2 Shutup pas2c unc0rr parents: 7714 diff changeset	527	n:= nf.QWordValue;
7714 981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	528
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	529	l:= 0;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	530	r:= 1024;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	531	c:= 0;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	532
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	533	repeat
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	534	oc:= c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	535
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	536	c:= (l + r) shr 1;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	537
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	538	if n >= SinTable[c] then
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	539	l:= c
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	540	else
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	541	r:= c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	542
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	543	until (oc = c);
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	544
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	545	if x.isNegative then c:= 2048 - c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	546	if y.isNegative then c:= - c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	547
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	548	vector2Angle:= c
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	549	end;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048 unc0rr parents: 7688 diff changeset	550
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: diff changeset	551	end.

author	koda
	Tue, 21 Jan 2014 22:38:13 +0100
changeset 10015	4feced261c68
parent 9998	736015b847e3
parent 9970	88353250ad7d
child 10108	c68cf030eded
permissions	-rw-r--r--