author | unc0rr |
Mon, 18 Jun 2012 23:45:21 +0400 | |
changeset 7262 | 33e703cc7a7f |
parent 7043 | 7c080e5ac8d0 |
child 7515 | 8957b05d368a |
permissions | -rw-r--r-- |
351 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com> |
351 | 4 |
* |
5 |
* This program is free software; you can redistribute it and/or modify |
|
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
8 |
* |
|
9 |
* This program is distributed in the hope that it will be useful, |
|
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
13 |
* |
|
14 |
* You should have received a copy of the GNU General Public License |
|
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
17 |
*) |
|
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
351 | 21 |
unit uFloat; |
5122 | 22 |
(* |
23 |
* This unit provides a custom data type, hwFloat. |
|
24 |
* |
|
25 |
* hwFloat represents a floating point number - the value and operations |
|
26 |
* of this numbers are independent from the hardware architecture |
|
27 |
* the game runs on. |
|
28 |
* |
|
29 |
* This is important for calculations that affect the course of the game |
|
30 |
* and would lead to different results if based on a hardware dependent |
|
31 |
* data type. |
|
32 |
* |
|
33 |
* Note: Not all comparisons are implemented. |
|
34 |
* |
|
35 |
* Note: Below you'll find a list of hwFloat constants: |
|
36 |
* E.g. _1 is an hwFloat with value 1.0, and -_0_9 is -0.9 |
|
5124 | 37 |
* Use and extend the list if needed, rather than using int2hwFloat() |
38 |
* with integer constants. |
|
5122 | 39 |
*) |
351 | 40 |
interface |
41 |
||
42 |
{$IFDEF FPC} |
|
2599 | 43 |
{$IFDEF ENDIAN_LITTLE} |
351 | 44 |
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
|
45 |
isNegative: boolean; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
46 |
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
|
47 |
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
|
48 |
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
|
49 |
end; |
2599 | 50 |
{$ELSE} |
351 | 51 |
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
|
52 |
isNegative: boolean; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
53 |
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
|
54 |
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
|
55 |
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
|
56 |
end; |
2599 | 57 |
{$ENDIF} |
351 | 58 |
|
5122 | 59 |
// Returns an hwFloat that represents the value of integer parameter i |
3599 | 60 |
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
|
61 |
function hwFloat2Float (const i: hwFloat) : extended; inline; |
351 | 62 |
|
5122 | 63 |
// The implemented operators |
64 |
||
6415 | 65 |
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
|
66 |
{$IFDEF PAS2C} |
7042
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
67 |
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
|
68 |
{$ENDIF} |
3599 | 69 |
operator + (const z1, z2: hwFloat) z : hwFloat; inline; |
70 |
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
|
71 |
operator - (const z1: hwFloat) z : hwFloat; inline; |
351 | 72 |
|
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
|
73 |
operator * (const z1, z2: hwFloat) z : hwFloat; inline; |
3599 | 74 |
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
|
75 |
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
|
76 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
351 | 77 |
|
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
|
78 |
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
|
79 |
operator > (const z1, z2: hwFloat) b : boolean; inline; |
351 | 80 |
|
5122 | 81 |
|
82 |
// Various functions for hwFloat (some are inlined in the resulting code for better performance) |
|
83 |
||
84 |
function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat. |
|
85 |
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) |
|
86 |
function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign. |
|
87 |
function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t. |
|
6785 | 88 |
function hwPow(const t: hwFloat; p: LongWord): hwFloat; inline; // Returns the power of the value |
5122 | 89 |
function hwSqrt(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t. |
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. |
|
91 |
function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters. |
|
515 | 92 |
function AngleSin(const Angle: Longword): hwFloat; |
93 |
function AngleCos(const Angle: Longword): hwFloat; |
|
5122 | 94 |
function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum. |
95 |
function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r. |
|
6879 | 96 |
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
|
97 |
function isZero(const z: hwFloat): boolean; inline; |
2599 | 98 |
{$IFDEF FPC} |
538 | 99 |
{$J-} |
2599 | 100 |
{$ENDIF} |
611 | 101 |
{$WARNINGS OFF} |
5122 | 102 |
|
103 |
||
104 |
// some hwFloat constants |
|
105 |
||
351 | 106 |
const _1div1024: hwFloat = (isNegative: false; QWordValue: 4194304); |
107 |
_1div10000: hwFloat = (isNegative: false; QWordValue: 429496); |
|
108 |
_1div50000: hwFloat = (isNegative: false; QWordValue: 85899); |
|
109 |
_1div100000: hwFloat = (isNegative: false; QWordValue: 42950); |
|
110 |
_1div3: hwFloat = (isNegative: false; QWordValue: 1431655766); |
|
111 |
hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704); |
|
112 |
_0_000004: hwFloat = (isNegative: false; QWordValue: 17179); |
|
3591 | 113 |
_0_000064: hwFloat = (isNegative: false; QWordValue: 274878); |
351 | 114 |
_0_0002: hwFloat = (isNegative: false; QWordValue: 858993); |
1586 | 115 |
_0_0005: hwFloat = (isNegative: false; QWordValue: 2147484); |
351 | 116 |
_0_001: hwFloat = (isNegative: false; QWordValue: 4294967); |
117 |
_0_003: hwFloat = (isNegative: false; QWordValue: 12884902); |
|
118 |
_0_004: hwFloat = (isNegative: false; QWordValue: 17179869); |
|
119 |
_0_005: hwFloat = (isNegative: false; QWordValue: 21474836); |
|
3428 | 120 |
_0_008: hwFloat = (isNegative: false; QWordValue: 34359738); |
351 | 121 |
_0_01: hwFloat = (isNegative: false; QWordValue: 42949673); |
122 |
_0_02: hwFloat = (isNegative: false; QWordValue: 85899345); |
|
123 |
_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
|
124 |
_0_07: hwFloat = (isNegative: false; QWordValue: 300647710); |
351 | 125 |
_0_08: hwFloat = (isNegative: false; QWordValue: 343597383); |
365 | 126 |
_0_1: hwFloat = (isNegative: false; QWordValue: 429496730); |
351 | 127 |
_0_15: hwFloat = (isNegative: false; QWordValue: 644245094); |
128 |
_0_2: hwFloat = (isNegative: false; QWordValue: 858993459); |
|
129 |
_0_25: hwFloat = (isNegative: false; QWordValue: 1073741824); |
|
130 |
_0_3: hwFloat = (isNegative: false; QWordValue: 1288490189); |
|
131 |
_0_35: hwFloat = (isNegative: false; QWordValue: 1503238553); |
|
2784 | 132 |
_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
|
133 |
_0_39: hwFloat = (isNegative: false; QWordValue: 1675037245); |
351 | 134 |
_0_4: hwFloat = (isNegative: false; QWordValue: 1717986918); |
135 |
_0_45: hwFloat = (isNegative: false; QWordValue: 1932735283); |
|
136 |
_0_5: hwFloat = (isNegative: false; QWordValue: 2147483648); |
|
137 |
_0_55: hwFloat = (isNegative: false; QWordValue: 2362232012); |
|
138 |
_0_6: hwFloat = (isNegative: false; QWordValue: 2576980377); |
|
3583 | 139 |
_0_64: hwFloat = (isNegative: false; QWordValue: 2748779064); |
358 | 140 |
_0_7: hwFloat = (isNegative: false; QWordValue: 3006477107); |
351 | 141 |
_0_8: hwFloat = (isNegative: false; QWordValue: 3435973837); |
142 |
_0_84: hwFloat = (isNegative: false; QWordValue: 3607772528); |
|
143 |
_0_87: hwFloat = (isNegative: false; QWordValue: 3736621547); |
|
144 |
_0_9: hwFloat = (isNegative: false; QWordValue: 3865470566); |
|
145 |
_0_93: hwFloat = (isNegative: false; QWordValue: 3994319585); |
|
146 |
_0_96: hwFloat = (isNegative: false; QWordValue: 4123168604); |
|
147 |
_0_995: hwFloat = (isNegative: false; QWordValue: 4273492459); |
|
148 |
_0_999: hwFloat = (isNegative: false; QWordValue: 4290672328); |
|
498 | 149 |
_0: hwFloat = (isNegative: false; QWordValue: 0); |
150 |
_1: hwFloat = (isNegative: false; QWordValue: 4294967296); |
|
513
69e06d710d46
Moving hedgehog could get another hedgehog moving forward
unc0rr
parents:
498
diff
changeset
|
151 |
_1_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 2); |
3584 | 152 |
_1_9: hwFloat = (isNegative: false; QWordValue: 8160437862); |
498 | 153 |
_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2); |
154 |
_3: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3); |
|
6785 | 155 |
_PI: hwFloat = (isNegative: false; QWordValue: 13493037704); |
498 | 156 |
_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4); |
6498 | 157 |
_4_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 9 div 2); |
498 | 158 |
_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 5); |
159 |
_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6); |
|
160 |
_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
|
161 |
_12: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12); |
498 | 162 |
_16: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16); |
163 |
_19: hwFloat = (isNegative: false; QWordValue: 4294967296 * 19); |
|
164 |
_20: hwFloat = (isNegative: false; QWordValue: 4294967296 * 20); |
|
165 |
_25: hwFloat = (isNegative: false; QWordValue: 4294967296 * 25); |
|
166 |
_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
|
167 |
_40: hwFloat = (isNegative: false; QWordValue: 4294967296 * 40); |
3036
c6ba6531cb4b
Make barrels a little more likely to blow up. 25% more damage in fall
nemo
parents:
2955
diff
changeset
|
168 |
_50: hwFloat = (isNegative: false; QWordValue: 4294967296 * 50); |
2933 | 169 |
_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
|
170 |
_90: hwFloat = (isNegative: false; QWordValue: 4294967296 * 90); |
498 | 171 |
_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
|
172 |
_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
|
173 |
_250: hwFloat = (isNegative: false; QWordValue: 4294967296 * 250); |
1915 | 174 |
_256: hwFloat = (isNegative: false; QWordValue: 4294967296 * 256); |
1124 | 175 |
_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
|
176 |
_360: hwFloat = (isNegative: false; QWordValue: 4294967296 * 360); |
498 | 177 |
_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
|
178 |
_1000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1000); |
611 | 179 |
_1024: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1024); |
180 |
_2048: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2048); |
|
1753 | 181 |
_4096: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4096); |
498 | 182 |
_10000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10000); |
351 | 183 |
|
184 |
cLittle: hwFloat = (isNegative: false; QWordValue: 1); |
|
967 | 185 |
cHHKick: hwFloat = (isNegative: false; QWordValue: 42949673); // _0_01 |
611 | 186 |
{$WARNINGS ON} |
351 | 187 |
{$ENDIF} |
188 |
||
189 |
{$IFNDEF FPC} |
|
190 |
type hwFloat = Extended; |
|
191 |
{$ENDIF} |
|
192 |
||
193 |
implementation |
|
4415 | 194 |
uses uSinTable; |
351 | 195 |
|
3599 | 196 |
|
351 | 197 |
{$IFDEF FPC} |
198 |
||
515 | 199 |
function int2hwFloat (const i: LongInt) : hwFloat; |
351 | 200 |
begin |
498 | 201 |
int2hwFloat.isNegative:= i < 0; |
202 |
int2hwFloat.Round:= abs(i); |
|
203 |
int2hwFloat.Frac:= 0 |
|
351 | 204 |
end; |
205 |
||
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
206 |
function hwFloat2Float (const i: hwFloat) : extended; |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
207 |
begin |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
208 |
hwFloat2Float:= i.QWordValue / $100000000; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
209 |
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
|
210 |
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
|
211 |
end; |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
212 |
|
6415 | 213 |
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
|
214 |
begin |
5665 | 215 |
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
|
216 |
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
|
217 |
|
7043
7c080e5ac8d0
Some work to make more units compile after conversion to c
unc0rr
parents:
7042
diff
changeset
|
218 |
{$IFDEF PAS2C} |
7042
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
219 |
operator <> (const z1, z2: hwFloat) z : boolean; inline; |
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
220 |
begin |
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
221 |
z:= (z1.isNegative <> z2.isNegative) or (z1.QWordValue <> z2.QWordValue); |
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
222 |
end; |
7043
7c080e5ac8d0
Some work to make more units compile after conversion to c
unc0rr
parents:
7042
diff
changeset
|
223 |
{$ENDIF} |
7042
de20086a6bcc
Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents:
6879
diff
changeset
|
224 |
|
515 | 225 |
operator + (const z1, z2: hwFloat) z : hwFloat; |
351 | 226 |
begin |
227 |
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
|
228 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
229 |
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
|
230 |
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
|
231 |
end |
351 | 232 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
233 |
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
|
234 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
235 |
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
|
236 |
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
|
237 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
238 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
239 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
240 |
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
|
241 |
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
|
242 |
end |
351 | 243 |
end; |
244 |
||
515 | 245 |
operator - (const z1, z2: hwFloat) z : hwFloat; |
351 | 246 |
begin |
247 |
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
|
248 |
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
|
249 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
250 |
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
|
251 |
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
|
252 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
253 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
254 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
255 |
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
|
256 |
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
|
257 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
258 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
259 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
260 |
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
|
261 |
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
|
262 |
end |
351 | 263 |
end; |
264 |
||
515 | 265 |
operator - (const z1: hwFloat) z : hwFloat; |
351 | 266 |
begin |
267 |
z:= z1; |
|
268 |
z.isNegative:= not z.isNegative |
|
269 |
end; |
|
270 |
||
271 |
||
515 | 272 |
operator * (const z1, z2: hwFloat) z : hwFloat; |
351 | 273 |
begin |
274 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
275 |
z.QWordValue:= QWord(z1.Round) * z2.Frac + QWord(z1.Frac) * z2.Round + ((QWord(z1.Frac) * z2.Frac) shr 32); |
351 | 276 |
z.Round:= z.Round + QWord(z1.Round) * z2.Round; |
277 |
end; |
|
278 |
||
515 | 279 |
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; |
351 | 280 |
begin |
281 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 282 |
z.QWordValue:= z1.QWordValue * abs(z2) |
351 | 283 |
end; |
284 |
||
515 | 285 |
operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; |
351 | 286 |
var t: hwFloat; |
287 |
begin |
|
288 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
289 |
z.Round:= z1.QWordValue div z2.QWordValue; |
|
290 |
t:= z1 - z2 * z.Round; |
|
291 |
if t.QWordValue = 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
|
292 |
z.Frac:= 0 |
351 | 293 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
294 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
295 |
while ((t.QWordValue and $8000000000000000) = 0) and ((z2.QWordValue and $8000000000000000) = 0) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
296 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
297 |
t.QWordValue:= t.QWordValue shl 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
298 |
z2.QWordValue:= z2.QWordValue shl 1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
299 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
300 |
if z2.Round > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
301 |
z.Frac:= (t.QWordValue) div (z2.Round) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
302 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
303 |
z.Frac:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
304 |
end |
351 | 305 |
end; |
306 |
||
515 | 307 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; |
498 | 308 |
begin |
309 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 310 |
z.QWordValue:= z1.QWordValue div abs(z2) |
498 | 311 |
end; |
312 |
||
515 | 313 |
operator < (const z1, z2: hwFloat) b : boolean; |
351 | 314 |
begin |
916 | 315 |
if z1.isNegative xor 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
|
316 |
b:= z1.isNegative |
351 | 317 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
318 |
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
|
319 |
b:= false |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
320 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
321 |
b:= (z1.QWordValue < z2.QWordValue) xor z1.isNegative |
351 | 322 |
end; |
323 |
||
515 | 324 |
operator > (const z1, z2: hwFloat) b : boolean; |
351 | 325 |
begin |
916 | 326 |
if z1.isNegative xor 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
|
327 |
b:= z2.isNegative |
351 | 328 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
329 |
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
|
330 |
b:= false |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
331 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
332 |
b:= (z1.QWordValue > z2.QWordValue) xor z2.isNegative |
351 | 333 |
end; |
334 |
||
2905 | 335 |
function cstr(const z: hwFloat): shortstring; |
336 |
var tmpstr: shortstring; |
|
351 | 337 |
begin |
338 |
str(z.Round, cstr); |
|
339 |
if z.Frac <> 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
|
340 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
341 |
str(z.Frac / $100000000, tmpstr); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
342 |
delete(tmpstr, 1, 2); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
343 |
cstr:= cstr + '.' + copy(tmpstr, 1, 10) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
344 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
345 |
if z.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
346 |
cstr:= '-' + cstr |
351 | 347 |
end; |
348 |
||
515 | 349 |
function hwRound(const t: hwFloat): LongInt; |
351 | 350 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
351 |
if t.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
352 |
hwRound:= -(t.Round and $7FFFFFFF) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
353 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
354 |
hwRound:= t.Round and $7FFFFFFF |
351 | 355 |
end; |
356 |
||
515 | 357 |
function hwAbs(const t: hwFloat): hwFloat; |
351 | 358 |
begin |
359 |
hwAbs:= t; |
|
360 |
hwAbs.isNegative:= false |
|
361 |
end; |
|
362 |
||
515 | 363 |
function hwSqr(const t: hwFloat): hwFloat; |
351 | 364 |
begin |
1433 | 365 |
hwSqr.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
|
366 |
hwSqr.QWordValue:= ((QWord(t.Round) * t.Round) shl 32) + QWord(t.Round) * t.Frac * 2 + ((QWord(t.Frac) * t.Frac) shr 32); |
351 | 367 |
end; |
368 |
||
6785 | 369 |
function hwPow(const t: hwFloat;p: LongWord): hwFloat; |
370 |
begin |
|
371 |
hwPow:= t; |
|
372 |
if p mod 2 = 0 then hwPow.isNegative:= t.isNegative; |
|
373 |
||
374 |
while p > 0 do |
|
375 |
begin |
|
376 |
hwPow.QWordValue:= QWord(hwPow.Round) * t.Frac + QWord(hwPow.Frac) * t.Round + ((QWord(hwPow.Frac) * t.Frac) shr 32); |
|
377 |
dec(p) |
|
378 |
end |
|
379 |
end; |
|
380 |
||
515 | 381 |
function hwSqrt(const t: hwFloat): hwFloat; |
738 | 382 |
var l, r: QWord; |
383 |
c: hwFloat; |
|
357 | 384 |
begin |
385 |
hwSqrt.isNegative:= false; |
|
744 | 386 |
|
387 |
if t.Round = 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
|
388 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
389 |
l:= t.QWordValue; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
390 |
r:= $100000000 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
391 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
392 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
393 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
394 |
l:= $100000000; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
395 |
r:= t.QWordValue div 2 + $80000000; // r:= t / 2 + 0.5 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
396 |
if r > $FFFFFFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
397 |
r:= $FFFFFFFFFFFF |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
398 |
end; |
744 | 399 |
|
738 | 400 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
401 |
c.QWordValue:= (l + r) div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
402 |
if hwSqr(c).QWordValue > t.QWordValue then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
403 |
r:= c.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
404 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
405 |
l:= c.QWordValue |
738 | 406 |
until r - l <= 1; |
744 | 407 |
|
738 | 408 |
hwSqrt.QWordValue:= l |
357 | 409 |
end; |
410 |
||
515 | 411 |
function Distance(const dx, dy: hwFloat): hwFloat; |
351 | 412 |
begin |
738 | 413 |
Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy)) |
351 | 414 |
end; |
415 |
||
515 | 416 |
function DistanceI(const dx, dy: LongInt): hwFloat; |
498 | 417 |
begin |
856 | 418 |
DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy))) |
498 | 419 |
end; |
420 |
||
515 | 421 |
function SignAs(const num, signum: hwFloat): hwFloat; |
498 | 422 |
begin |
856 | 423 |
SignAs.QWordValue:= num.QWordValue; |
498 | 424 |
SignAs.isNegative:= signum.isNegative |
425 |
end; |
|
426 |
||
4374 | 427 |
function hwSign(r: hwFloat): LongInt; |
428 |
begin |
|
429 |
// 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
|
430 |
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
|
431 |
hwSign:= -1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
432 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
433 |
hwSign:= 1 |
4374 | 434 |
end; |
435 |
||
6879 | 436 |
function hwSignf(r: real): LongInt; |
6775 | 437 |
begin |
438 |
if r < 0 then |
|
6879 | 439 |
hwSignf:= -1 |
6775 | 440 |
else |
6879 | 441 |
hwSignf:= 1 |
6775 | 442 |
end; |
443 |
||
357 | 444 |
|
515 | 445 |
function AngleSin(const Angle: Longword): hwFloat; |
351 | 446 |
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
|
447 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true); |
351 | 448 |
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
|
449 |
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
|
450 |
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
|
451 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
452 |
AngleSin.QWordValue:= SinTable[2048 - Angle] |
351 | 453 |
end; |
454 |
||
515 | 455 |
function AngleCos(const Angle: Longword): hwFloat; |
351 | 456 |
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
|
457 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true); |
357 | 458 |
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
|
459 |
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
|
460 |
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
|
461 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
462 |
AngleCos.QWordValue:= SinTable[Angle - 1024] |
351 | 463 |
end; |
464 |
||
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
|
465 |
function isZero(const z: hwFloat): boolean; inline; |
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
|
466 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
467 |
isZero := z.QWordValue = 0; |
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
|
468 |
end; |
351 | 469 |
{$ENDIF} |
470 |
||
471 |
end. |