author | Xeli |
Sun, 21 Aug 2011 18:14:49 +0200 | |
branch | hedgeroid |
changeset 5625 | 9add7b92c5f0 |
parent 5599 | 2e4b90f33a83 |
child 5665 | 8805f3167058 |
permissions | -rw-r--r-- |
351 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
4976 | 3 |
* Copyright (c) 2004-2011 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 |
45 |
isNegative: boolean; |
|
46 |
case byte of |
|
47 |
0: (Frac, Round: Longword); |
|
48 |
1: (QWordValue : QWord); |
|
49 |
end; |
|
2599 | 50 |
{$ELSE} |
351 | 51 |
type hwFloat = record |
52 |
isNegative: boolean; |
|
53 |
case byte of |
|
54 |
0: (Round, Frac: Longword); |
|
55 |
1: (QWordValue : QWord); |
|
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 |
||
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
|
65 |
operator = (const z1, z2: hwFloat) z:boolean; inline; |
3599 | 66 |
operator + (const z1, z2: hwFloat) z : hwFloat; inline; |
67 |
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
|
68 |
operator - (const z1: hwFloat) z : hwFloat; inline; |
351 | 69 |
|
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, z2: hwFloat) z : hwFloat; inline; |
3599 | 71 |
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
|
72 |
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
|
73 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
351 | 74 |
|
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, 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
|
76 |
operator > (const z1, z2: hwFloat) b : boolean; inline; |
351 | 77 |
|
5122 | 78 |
|
79 |
// Various functions for hwFloat (some are inlined in the resulting code for better performance) |
|
80 |
||
81 |
function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat. |
|
82 |
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) |
|
83 |
function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign. |
|
84 |
function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t. |
|
85 |
function hwSqrt(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t. |
|
86 |
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. |
|
87 |
function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters. |
|
515 | 88 |
function AngleSin(const Angle: Longword): hwFloat; |
89 |
function AngleCos(const Angle: Longword): hwFloat; |
|
5122 | 90 |
function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum. |
91 |
function hwSign(r: hwFloat): 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
|
92 |
function isZero(const z: hwFloat): boolean; inline; |
2599 | 93 |
{$IFDEF FPC} |
538 | 94 |
{$J-} |
2599 | 95 |
{$ENDIF} |
611 | 96 |
{$WARNINGS OFF} |
5122 | 97 |
|
98 |
||
99 |
// some hwFloat constants |
|
100 |
||
351 | 101 |
const _1div1024: hwFloat = (isNegative: false; QWordValue: 4194304); |
102 |
_1div10000: hwFloat = (isNegative: false; QWordValue: 429496); |
|
103 |
_1div50000: hwFloat = (isNegative: false; QWordValue: 85899); |
|
104 |
_1div100000: hwFloat = (isNegative: false; QWordValue: 42950); |
|
105 |
_1div3: hwFloat = (isNegative: false; QWordValue: 1431655766); |
|
106 |
hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704); |
|
107 |
_0_000004: hwFloat = (isNegative: false; QWordValue: 17179); |
|
3591 | 108 |
_0_000064: hwFloat = (isNegative: false; QWordValue: 274878); |
351 | 109 |
_0_0002: hwFloat = (isNegative: false; QWordValue: 858993); |
1586 | 110 |
_0_0005: hwFloat = (isNegative: false; QWordValue: 2147484); |
351 | 111 |
_0_001: hwFloat = (isNegative: false; QWordValue: 4294967); |
112 |
_0_003: hwFloat = (isNegative: false; QWordValue: 12884902); |
|
113 |
_0_004: hwFloat = (isNegative: false; QWordValue: 17179869); |
|
114 |
_0_005: hwFloat = (isNegative: false; QWordValue: 21474836); |
|
3428 | 115 |
_0_008: hwFloat = (isNegative: false; QWordValue: 34359738); |
351 | 116 |
_0_01: hwFloat = (isNegative: false; QWordValue: 42949673); |
117 |
_0_02: hwFloat = (isNegative: false; QWordValue: 85899345); |
|
118 |
_0_03: hwFloat = (isNegative: false; QWordValue: 128849018); |
|
119 |
_0_08: hwFloat = (isNegative: false; QWordValue: 343597383); |
|
365 | 120 |
_0_1: hwFloat = (isNegative: false; QWordValue: 429496730); |
351 | 121 |
_0_15: hwFloat = (isNegative: false; QWordValue: 644245094); |
122 |
_0_2: hwFloat = (isNegative: false; QWordValue: 858993459); |
|
123 |
_0_25: hwFloat = (isNegative: false; QWordValue: 1073741824); |
|
124 |
_0_3: hwFloat = (isNegative: false; QWordValue: 1288490189); |
|
125 |
_0_35: hwFloat = (isNegative: false; QWordValue: 1503238553); |
|
2784 | 126 |
_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
|
127 |
_0_39: hwFloat = (isNegative: false; QWordValue: 1675037245); |
351 | 128 |
_0_4: hwFloat = (isNegative: false; QWordValue: 1717986918); |
129 |
_0_45: hwFloat = (isNegative: false; QWordValue: 1932735283); |
|
130 |
_0_5: hwFloat = (isNegative: false; QWordValue: 2147483648); |
|
131 |
_0_55: hwFloat = (isNegative: false; QWordValue: 2362232012); |
|
132 |
_0_6: hwFloat = (isNegative: false; QWordValue: 2576980377); |
|
3583 | 133 |
_0_64: hwFloat = (isNegative: false; QWordValue: 2748779064); |
358 | 134 |
_0_7: hwFloat = (isNegative: false; QWordValue: 3006477107); |
351 | 135 |
_0_8: hwFloat = (isNegative: false; QWordValue: 3435973837); |
136 |
_0_84: hwFloat = (isNegative: false; QWordValue: 3607772528); |
|
137 |
_0_87: hwFloat = (isNegative: false; QWordValue: 3736621547); |
|
138 |
_0_9: hwFloat = (isNegative: false; QWordValue: 3865470566); |
|
139 |
_0_93: hwFloat = (isNegative: false; QWordValue: 3994319585); |
|
140 |
_0_96: hwFloat = (isNegative: false; QWordValue: 4123168604); |
|
141 |
_0_995: hwFloat = (isNegative: false; QWordValue: 4273492459); |
|
142 |
_0_999: hwFloat = (isNegative: false; QWordValue: 4290672328); |
|
498 | 143 |
_0: hwFloat = (isNegative: false; QWordValue: 0); |
144 |
_1: hwFloat = (isNegative: false; QWordValue: 4294967296); |
|
513
69e06d710d46
Moving hedgehog could get another hedgehog moving forward
unc0rr
parents:
498
diff
changeset
|
145 |
_1_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 2); |
3584 | 146 |
_1_9: hwFloat = (isNegative: false; QWordValue: 8160437862); |
498 | 147 |
_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2); |
148 |
_3: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3); |
|
149 |
_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4); |
|
150 |
_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 5); |
|
151 |
_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6); |
|
152 |
_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
|
153 |
_12: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12); |
498 | 154 |
_16: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16); |
155 |
_19: hwFloat = (isNegative: false; QWordValue: 4294967296 * 19); |
|
156 |
_20: hwFloat = (isNegative: false; QWordValue: 4294967296 * 20); |
|
157 |
_25: hwFloat = (isNegative: false; QWordValue: 4294967296 * 25); |
|
158 |
_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
|
159 |
_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
|
160 |
_50: hwFloat = (isNegative: false; QWordValue: 4294967296 * 50); |
2933 | 161 |
_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
|
162 |
_90: hwFloat = (isNegative: false; QWordValue: 4294967296 * 90); |
498 | 163 |
_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
|
164 |
_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
|
165 |
_250: hwFloat = (isNegative: false; QWordValue: 4294967296 * 250); |
1915 | 166 |
_256: hwFloat = (isNegative: false; QWordValue: 4294967296 * 256); |
1124 | 167 |
_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
|
168 |
_360: hwFloat = (isNegative: false; QWordValue: 4294967296 * 360); |
498 | 169 |
_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
|
170 |
_1000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1000); |
611 | 171 |
_1024: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1024); |
172 |
_2048: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2048); |
|
1753 | 173 |
_4096: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4096); |
498 | 174 |
_10000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10000); |
351 | 175 |
|
176 |
cLittle: hwFloat = (isNegative: false; QWordValue: 1); |
|
967 | 177 |
cHHKick: hwFloat = (isNegative: false; QWordValue: 42949673); // _0_01 |
611 | 178 |
{$WARNINGS ON} |
351 | 179 |
{$ENDIF} |
180 |
||
181 |
{$IFNDEF FPC} |
|
182 |
type hwFloat = Extended; |
|
183 |
{$ENDIF} |
|
184 |
||
185 |
implementation |
|
4415 | 186 |
uses uSinTable; |
351 | 187 |
|
3599 | 188 |
|
351 | 189 |
{$IFDEF FPC} |
190 |
||
515 | 191 |
function int2hwFloat (const i: LongInt) : hwFloat; |
351 | 192 |
begin |
498 | 193 |
int2hwFloat.isNegative:= i < 0; |
194 |
int2hwFloat.Round:= abs(i); |
|
195 |
int2hwFloat.Frac:= 0 |
|
351 | 196 |
end; |
197 |
||
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
198 |
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
|
199 |
begin |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
200 |
hwFloat2Float:= i.QWordValue / $100000000; |
5192 | 201 |
if i.isNegative then 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
|
202 |
end; |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
203 |
|
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
|
204 |
operator = (const z1, z2: hwFloat) z: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
|
205 |
begin |
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
|
206 |
z:= true; |
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
|
207 |
z:= z and (z1.isNegative = z2.isNegative); |
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
|
208 |
z:= z and (z1.QWordValue = z2.QWordValue); |
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
|
209 |
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
|
210 |
|
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
|
211 |
|
515 | 212 |
operator + (const z1, z2: hwFloat) z : hwFloat; |
351 | 213 |
begin |
214 |
if z1.isNegative = z2.isNegative then |
|
215 |
begin |
|
216 |
z.isNegative:= z1.isNegative; |
|
217 |
z.QWordValue:= z1.QWordValue + z2.QWordValue |
|
218 |
end |
|
219 |
else |
|
220 |
if z1.QWordValue > z2.QWordValue then |
|
221 |
begin |
|
222 |
z.isNegative:= z1.isNegative; |
|
223 |
z.QWordValue:= z1.QWordValue - z2.QWordValue |
|
224 |
end else |
|
225 |
begin |
|
226 |
z.isNegative:= z2.isNegative; |
|
227 |
z.QWordValue:= z2.QWordValue - z1.QWordValue |
|
228 |
end |
|
229 |
end; |
|
230 |
||
515 | 231 |
operator - (const z1, z2: hwFloat) z : hwFloat; |
351 | 232 |
begin |
233 |
if z1.isNegative = z2.isNegative then |
|
234 |
if z1.QWordValue > z2.QWordValue then |
|
235 |
begin |
|
236 |
z.isNegative:= z1.isNegative; |
|
237 |
z.QWordValue:= z1.QWordValue - z2.QWordValue |
|
238 |
end else |
|
239 |
begin |
|
240 |
z.isNegative:= not z2.isNegative; |
|
241 |
z.QWordValue:= z2.QWordValue - z1.QWordValue |
|
242 |
end |
|
243 |
else begin |
|
244 |
z.isNegative:= z1.isNegative; |
|
245 |
z.QWordValue:= z1.QWordValue + z2.QWordValue |
|
246 |
end |
|
247 |
end; |
|
248 |
||
515 | 249 |
operator - (const z1: hwFloat) z : hwFloat; |
351 | 250 |
begin |
251 |
z:= z1; |
|
252 |
z.isNegative:= not z.isNegative |
|
253 |
end; |
|
254 |
||
255 |
||
515 | 256 |
operator * (const z1, z2: hwFloat) z : hwFloat; |
351 | 257 |
begin |
258 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
259 |
z.QWordValue:= QWord(z1.Round) * z2.Frac + |
|
260 |
QWord(z1.Frac) * z2.Round + |
|
261 |
((QWord(z1.Frac) * z2.Frac) shr 32); |
|
262 |
z.Round:= z.Round + QWord(z1.Round) * z2.Round; |
|
263 |
end; |
|
264 |
||
515 | 265 |
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; |
351 | 266 |
begin |
267 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 268 |
z.QWordValue:= z1.QWordValue * abs(z2) |
351 | 269 |
end; |
270 |
||
515 | 271 |
operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; |
351 | 272 |
var t: hwFloat; |
273 |
begin |
|
274 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
275 |
z.Round:= z1.QWordValue div z2.QWordValue; |
|
276 |
t:= z1 - z2 * z.Round; |
|
277 |
if t.QWordValue = 0 then |
|
278 |
z.Frac:= 0 |
|
279 |
else |
|
280 |
begin |
|
281 |
while ((t.QWordValue and $8000000000000000) = 0) and |
|
282 |
((z2.QWordValue and $8000000000000000) = 0) do |
|
283 |
begin |
|
284 |
t.QWordValue:= t.QWordValue shl 1; |
|
285 |
z2.QWordValue:= z2.QWordValue shl 1 |
|
286 |
end; |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
538
diff
changeset
|
287 |
if z2.Round > 0 then z.Frac:= (t.QWordValue) div (z2.Round) |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
538
diff
changeset
|
288 |
else z.Frac:= 0 |
351 | 289 |
end |
290 |
end; |
|
291 |
||
515 | 292 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; |
498 | 293 |
begin |
294 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 295 |
z.QWordValue:= z1.QWordValue div abs(z2) |
498 | 296 |
end; |
297 |
||
515 | 298 |
operator < (const z1, z2: hwFloat) b : boolean; |
351 | 299 |
begin |
916 | 300 |
if z1.isNegative xor z2.isNegative then |
351 | 301 |
b:= z1.isNegative |
302 |
else |
|
303 |
if z1.QWordValue = z2.QWordValue then |
|
304 |
b:= false |
|
305 |
else |
|
306 |
b:= (z1.QWordValue < z2.QWordValue) xor z1.isNegative |
|
307 |
end; |
|
308 |
||
515 | 309 |
operator > (const z1, z2: hwFloat) b : boolean; |
351 | 310 |
begin |
916 | 311 |
if z1.isNegative xor z2.isNegative then |
351 | 312 |
b:= z2.isNegative |
313 |
else |
|
314 |
if z1.QWordValue = z2.QWordValue then |
|
315 |
b:= false |
|
316 |
else |
|
317 |
b:= (z1.QWordValue > z2.QWordValue) xor z2.isNegative |
|
318 |
end; |
|
319 |
||
2905 | 320 |
function cstr(const z: hwFloat): shortstring; |
321 |
var tmpstr: shortstring; |
|
351 | 322 |
begin |
323 |
str(z.Round, cstr); |
|
324 |
if z.Frac <> 0 then |
|
325 |
begin |
|
326 |
str(z.Frac / $100000000:1:15, tmpstr); |
|
327 |
delete(tmpstr, 1, 2); |
|
328 |
cstr:= cstr + '.' + tmpstr |
|
329 |
end; |
|
330 |
if z.isNegative then cstr:= '-' + cstr |
|
331 |
end; |
|
332 |
||
515 | 333 |
function hwRound(const t: hwFloat): LongInt; |
351 | 334 |
begin |
2300 | 335 |
if t.isNegative then hwRound:= -(t.Round and $7FFFFFFF) |
336 |
else hwRound:= t.Round and $7FFFFFFF |
|
351 | 337 |
end; |
338 |
||
515 | 339 |
function hwAbs(const t: hwFloat): hwFloat; |
351 | 340 |
begin |
341 |
hwAbs:= t; |
|
342 |
hwAbs.isNegative:= false |
|
343 |
end; |
|
344 |
||
515 | 345 |
function hwSqr(const t: hwFloat): hwFloat; |
351 | 346 |
begin |
1433 | 347 |
hwSqr.isNegative:= false; |
348 |
hwSqr.QWordValue:= |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2933
diff
changeset
|
349 |
((QWord(t.Round) * t.Round) shl 32) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2933
diff
changeset
|
350 |
+ QWord(t.Round) * t.Frac * 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2933
diff
changeset
|
351 |
+ ((QWord(t.Frac) * t.Frac) shr 32); |
351 | 352 |
end; |
353 |
||
515 | 354 |
function hwSqrt(const t: hwFloat): hwFloat; |
738 | 355 |
var l, r: QWord; |
356 |
c: hwFloat; |
|
357 | 357 |
begin |
358 |
hwSqrt.isNegative:= false; |
|
744 | 359 |
|
360 |
if t.Round = 0 then |
|
361 |
begin |
|
362 |
l:= t.QWordValue; |
|
363 |
r:= $100000000 |
|
364 |
end else |
|
365 |
begin |
|
366 |
l:= $100000000; |
|
953
237fc147950c
Fix bug in hwSqrt when calculating square root of number >= 65536
unc0rr
parents:
916
diff
changeset
|
367 |
r:= t.QWordValue div 2 + $80000000; // r:= t / 2 + 0.5 |
237fc147950c
Fix bug in hwSqrt when calculating square root of number >= 65536
unc0rr
parents:
916
diff
changeset
|
368 |
if r > $FFFFFFFFFFFF then r:= $FFFFFFFFFFFF |
744 | 369 |
end; |
370 |
||
738 | 371 |
repeat |
372 |
c.QWordValue:= (l + r) div 2; |
|
373 |
if hwSqr(c).QWordValue > t.QWordValue then r:= c.QWordValue else l:= c.QWordValue |
|
374 |
until r - l <= 1; |
|
744 | 375 |
|
738 | 376 |
hwSqrt.QWordValue:= l |
357 | 377 |
end; |
378 |
||
515 | 379 |
function Distance(const dx, dy: hwFloat): hwFloat; |
351 | 380 |
begin |
738 | 381 |
Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy)) |
351 | 382 |
end; |
383 |
||
515 | 384 |
function DistanceI(const dx, dy: LongInt): hwFloat; |
498 | 385 |
begin |
856 | 386 |
DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy))) |
498 | 387 |
end; |
388 |
||
515 | 389 |
function SignAs(const num, signum: hwFloat): hwFloat; |
498 | 390 |
begin |
856 | 391 |
SignAs.QWordValue:= num.QWordValue; |
498 | 392 |
SignAs.isNegative:= signum.isNegative |
393 |
end; |
|
394 |
||
4374 | 395 |
function hwSign(r: hwFloat): LongInt; |
396 |
begin |
|
397 |
// yes, we have negative zero for a reason |
|
398 |
if r.isNegative then hwSign:= -1 else hwSign:= 1 |
|
399 |
end; |
|
400 |
||
357 | 401 |
|
515 | 402 |
function AngleSin(const Angle: Longword): hwFloat; |
351 | 403 |
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
|
404 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true); |
351 | 405 |
AngleSin.isNegative:= false; |
357 | 406 |
if Angle < 1024 then AngleSin.QWordValue:= SinTable[Angle] |
407 |
else AngleSin.QWordValue:= SinTable[2048 - Angle] |
|
351 | 408 |
end; |
409 |
||
515 | 410 |
function AngleCos(const Angle: Longword): hwFloat; |
351 | 411 |
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
|
412 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true); |
357 | 413 |
AngleCos.isNegative:= Angle > 1024; |
414 |
if Angle < 1024 then AngleCos.QWordValue:= SinTable[1024 - Angle] |
|
415 |
else AngleCos.QWordValue:= SinTable[Angle - 1024] |
|
351 | 416 |
end; |
417 |
||
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
|
418 |
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
|
419 |
begin |
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
|
420 |
isZero := z.QWordValue = 0; |
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
|
421 |
end; |
351 | 422 |
{$ENDIF} |
423 |
||
424 |
end. |