source: Daodan/src/Daodan_BSL.c@ 637

Last change on this file since 637 was 484, checked in by gumby, 15 years ago

ZOMG FLATLINE

File size: 26.6 KB
RevLine 
[443]1#include <stdio.h>
[451]2#include <stdbool.h>
[440]3#include <time.h>
[443]4#include <ffi.h>
[481]5#include <math.h>
[451]6#include "inifile.h"
7
[439]8#include "Daodan_BSL.h"
[484]9#include "Flatline_BSL.h"
[444]10#include "Daodan_Utility.h"
[447]11#include "Daodan_Patch.h"
[444]12#include "Daodan_Console.h"
[445]13#include "BFW_ScriptLang.h"
[441]14#include "Oni.h"
15#include "Oni_Character.h"
[447]16#include "oni_gl.h"
[440]17#include "dSFMT\dSFMT.h"
[446]18#include "Daodan_Character.h"
[440]19
[484]20
21
[474]22uint16_t ONICALL bsl_int32mul(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[439]23{
24 ret->value_int32 = args[0].value_int32 * args[1].value_int32;
25 ret->type = sl_int32;
26 return 0;
27}
28
[474]29uint16_t ONICALL bsl_mul(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[439]30{
31 double val1;
32 double val2;
33
34 if (args[0].type == sl_int32)
35 val1 = args[0].value_int32;
36 else
37 val1 = args[0].value_float;
38
39 if (args[1].type == sl_int32)
40 val2 = args[1].value_int32;
41 else
42 val2 = args[1].value_float;
43
44 ret->value_float = (float)(val1 * val2);
45 ret->type = sl_float;
46 return 0;
47}
48
[474]49uint16_t ONICALL bsl_int32div(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[439]50{
51 ret->value_int32 = args[0].value_int32 / args[1].value_int32;
52 ret->type = sl_int32;
53 return 0;
54}
[474]55uint16_t ONICALL bsl_div(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[439]56{
57 double val1;
58 double val2;
59
60 if (args[0].type == sl_int32)
61 val1 = args[0].value_int32;
62 else
63 val1 = args[0].value_float;
64
65 if (args[1].type == sl_int32)
66 val2 = args[1].value_int32;
67 else
68 val2 = args[1].value_float;
69
70 ret->value_float = (float)(val1 / val2);
71 ret->type = sl_float;
72 return 0;
73}
[443]74
[474]75uint16_t ONICALL bsl_int32rand(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[443]76{
77 int32_t start = 0;
78 int32_t end = 0;
79
80 if (args[0].value_int32 == args[1].value_int32)
81 return 1;
82 else if (args[0].value_int32 > args[1].value_int32)
83 {
84 start = args[1].value_int32;
85 end = args[0].value_int32;
86 }
87 else
88 {
89 start = args[0].value_int32;
90 end = args[1].value_int32;
91 }
92
93 ret->value_int32 = start + (dsfmt_gv_genrand_uint32() % (uint32_t)(end - start + 1));
94 ret->type = sl_int32;
95 return 0;
96}
97
[474]98uint16_t ONICALL bsl_getkills(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[443]99{
100 int index;
101 if (numargs == 0) index = 0;
[446]102 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
[443]103 else index = args[0].value_int32;
104 int* killcount = ONgGameState + index * 0x16A0 + 0x1260 + 0x1670;
105 ret->value_int32 = *killcount;
106 ret->type = sl_int32;
107 return 0;
108}
109
[474]110uint16_t ONICALL bsl_getdamage(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[443]111{
112 int index;
113 if (numargs == 0) index = 0;
[446]114 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
[443]115 else index = args[0].value_int32;
116 int* killcount = ONgGameState + index * 0x16A0 + 0x1260 + 0x1674;
117 ret->value_int32 = *killcount;
118 ret->type = sl_int32;
119 return 0;
120}
[446]121
[474]122uint16_t ONICALL bsl_returnoffset(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[470]123{
124 //int offset = 140;
125 //if (== 1) offset = 148;
126 //else index = args[0].value_int32;
127 int* killcount = ONgGameState + args[0].value_int32;
128 ret->value_int32 = *killcount;
129 ret->type = sl_int32;
130 return 0;
131}
132
133
[474]134uint16_t ONICALL bsl_powerup(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]135{
136 int index;
137 if (numargs < 2 || args[1].type != sl_str32) return 1;
138 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
139 else index = args[0].value_int32;
[450]140 void* returnval;
141 bool is_lsi = 0;
142 Character* Chr = ONgGameState + 0x1260;
143 if(!strcmp(args[1].value_str32,"ammo"))
[446]144 {
[450]145 returnval = &(Chr[index].Inventory_.AmmoUsed);
146 }
147 else if(!strcmp(args[1].value_str32,"hypo"))
148 {
149 returnval = &(Chr[index].Inventory_.HypoUsed);
150 }
151 else if(!strcmp(args[1].value_str32,"cells"))
152 {
153 returnval = &(Chr[index].Inventory_.CellsUsed);
154 }
155 else if(!strcmp(args[1].value_str32,"invis"))
156 {
157 returnval = &(Chr[index].Inventory_.CloakUsed);
158 }
159 else if(!strcmp(args[1].value_str32,"shield"))
160 {
161 returnval = &(Chr[index].Inventory_.ShieldUsed);
162 }
163 else if(!strcmp(args[1].value_str32,"lsi"))
164 {
165 returnval = &(Chr[index].Inventory_.hasLSI);
166 is_lsi = 1;
167 }
[451]168// else if(!strcmp(args[1].value_str32,"bossshield"))
169// {
170// ret->value_int32 = Chr[index].Flags & char_bossshield;
171// ret->type = sl_int32;
172// if (numargs >=3) {
173// if (Chr[index].Flags & char_bossshield) Chr[index].Flags = Chr[index].Flags & ~char_bossshield;
174// else Chr[index].Flags = Chr[index].Flags | char_bossshield;
175// }
176// return 0;
177// }
[450]178 else return 1;
[446]179 //todo, add setting
180
[450]181 if(is_lsi) ret->value_int32 = (int)*(bool*)returnval;
182 else ret->value_int32 = *(int*)returnval;
183 ret->type = sl_int32;
184
185 if (numargs >= 3)
[446]186 {
[450]187 if(is_lsi) *(bool*)returnval = args[2].value_int32;
188 else *(int*)returnval = args[2].value_int32;
[446]189 }
[450]190
191
[446]192 return 0;
193}
194
[474]195uint16_t ONICALL bsl_health(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]196{
197 int index;
198 if (numargs == 0) index = 0;
199 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
200 else index = args[0].value_int32;
201 Character* Chr = ONgGameState + 0x1260 ;
202 int* health = &Chr[index].Health;
203
204 ret->value_int32 = *health;
205 ret->type = sl_int32;
206
207 if (numargs >= 2) {
208 *health = args[1].value_int32;
209 }
210 ret->value_int32 = *health;
211 ret->type = sl_int32;
212 return 0;
213}
214
[474]215uint16_t ONICALL bsl_regen(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[470]216{
217 int index;
218 if (numargs == 0) index = 0;
219 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
220 else index = args[0].value_int32;
221 Character* Chr = ONgGameState + 0x1260 ;
[484]222 int* health = (int*)Chr[index].ScriptNoPath;
223
224 /*
225 DDrConsole_PrintF("Character %s", Chr[index].Name);
226 DDrConsole_PrintF("Spawn %s", Chr[index].ScriptSpawn);
227 DDrConsole_PrintF("Death %s", Chr[index].ScriptDie);
228 DDrConsole_PrintF("Aware %s", Chr[index].ScriptAware);
229 DDrConsole_PrintF("Alarm %s", Chr[index].ScriptAlarm);
230 DDrConsole_PrintF("Hurt %s", Chr[index].ScriptHurt);
231 DDrConsole_PrintF("Defeat %s", Chr[index].ScriptDefeat);
232 DDrConsole_PrintF("NoAmmo %s", Chr[index].ScriptNoAmmo);
233 DDrConsole_PrintF("NoPath %s", Chr[index].ScriptNoPath);
234 */
[470]235 ret->value_int32 = *health;
236 ret->type = sl_int32;
237
238 if (numargs >= 2) {
239 *health = args[1].value_int32;
240 }
241 return 0;
242}
243
[481]244uint16_t ONICALL bsl_distance(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret) {
245
246 if (numargs < 2) return 1;
247 int index;
248 int index2;
249 if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
250 else index = args[0].value_int32;
251 if (index == -1) index = args[0].value_int32;
[470]252
[481]253 if (args[1].type == sl_str32) index2 = DDrGetCharacterIndexFromName(args[1].value_str32);
254 else index2 = args[1].value_int32;
255 if (index2 == -1) index2 = args[1].value_int32;
256
257 Character* Chr = ONgGameState + 0x1260;
258 Character* Char1 = &Chr[index];
259 Character* Char2 = &Chr[index2];
260
261 ret->value_float = sqrt( pow((Char1->Location.X - Char2->Location.X), 2) + pow((Char1->Location.Y - Char2->Location.Y), 2) + pow((Char1->Location.Z - Char2->Location.Z),2));
262 ret->type = sl_float;
263 return 0;
264}
265uint16_t ONICALL bsl_location(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret) {
266 int index;
267 if (numargs < 2) return 1;
268 if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
269 else index = args[0].value_int32;
270 if (index == -1) index = args[0].value_int32;
271 Character* Chr = ONgGameState + 0x1260;
272 float* loc;
273 if (!strcmp(args[1].value_str32,"X") || !strcmp(args[1].value_str32,"x"))
274 loc = &(Chr[index].Position.X);
275 else if (!strcmp(args[1].value_str32,"Y") || !strcmp(args[1].value_str32,"y"))
276 loc = &(Chr[index].Position.Y);
277 else if (!strcmp(args[1].value_str32,"Z") || !strcmp(args[1].value_str32,"z"))
278 loc = &(Chr[index].Position.Z);
279 else if (numargs == 4) {
280 //currently broken. crashes oni.
281 Chr[index].Position.X = args[1].value_float;
282 Chr[index].Position.Y = args[2].value_float;
283 Chr[index].Position.Z = args[3].value_float;
284 ret->value_float = 1;
285 ret->type = sl_float;
286 return 0;
287 }
288 else return 1;
289
290 ret->value_float = *loc;
291 ret->type = sl_float;
292
293 if(numargs == 3) {
294 //currently broken, does nothing.
295 *loc = args[2].value_float;
296 }
297 return 0;
298}
299
[474]300uint16_t ONICALL bsl_maxhealth(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]301{
302 int index;
303 if (numargs == 0) index = 0;
304 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
305 else index = args[0].value_int32;
306 Character* Chr = ONgGameState + 0x1260 ;
307 int* maxhealth = &Chr[index].MaxHealth;
308 int oldmaxhealth = Chr[index].MaxHealth;
309 int oldhealth = Chr->Health;
310 if (numargs >= 2) {
311 *maxhealth = args[1].value_int32;
312 }
313 if (numargs >= 3 && args[2].value_bool) {
314 Chr->Health = (int)(((float)args[1].value_int32 / (float)oldmaxhealth) * (float)oldhealth);
315 }
316 ret->value_int32 = oldmaxhealth;
317 ret->type = sl_int32;
318 return 0;
319}
320
[474]321uint16_t ONICALL bsl_getattacker(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]322{
[470]323 //broken
324
[446]325 int index;
[450]326 if (numargs == 0) index = 0;
327 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
[446]328 else index = args[0].value_int32;
329
[450]330 Character* Chr = ONgGameState + 0x1260;
331 ActiveCharacter* Active = (ActiveCharacter*)ONrGetActiveCharacter(&Chr[index]);
332 if ((int)Active == 0) return 1;
[451]333// ret->value_int32 = Active->LastDamageSourceCharacter;
[446]334 ret->type = sl_int32;
335 return 0;
336}
337
338
[450]339
[474]340uint16_t ONICALL bsl_chrname(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]341{
342 int index;
343 if (numargs == 0) index = 0;
344 else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
345 else index = args[0].value_int32;
346 if (index == -1) {
347 ret->type = sl_str32;
348 ret->value_str32 = "NULL";
349 return 0;
350 }
351 char* name = ONgGameState + 0x1260 + index * 0x16A0 + 0x14;
352 if (numargs == 2) {
353 strncpy(name, (char*)args[1].value_str32, 31);
354 }
355
356 ret->type = sl_str32;
357 ret->value_str32 = name;
358
359 return 0;
360}
361
362
[474]363uint16_t ONICALL bsl_count(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]364{
365 //testing numargs...
366 ret->type = sl_int32;
367 ret->value_int32 = numargs;
368 return 0;
369}
370
[474]371uint16_t ONICALL bsl_dprintcolored(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]372{
373 //TODO: figure out why our implementation of dprint shows after dev mode is turned off
374 RGBA color;
375 RGBA shade;
376
377 if(numargs == 0) return 0;
378 if(numargs > 1 ) color.R = (char)args[1].value_int32;
379 else color.R = 255;
380 if(numargs > 2 ) color.G = (char)args[2].value_int32;
381 else color.G = 255;
382 if(numargs > 3 ) color.B = (char)args[3].value_int32;
383 else color.B = 255;
384 color.A = 0;
385 if(numargs > 5 ) shade.R = (char)args[5].value_int32;
386 else shade.R = 0x3F;
387 if(numargs > 6 ) shade.G = (char)args[6].value_int32;
388 else shade.G = 0x3F;
389 if(numargs > 7 ) shade.B = (char)args[7].value_int32;
390 else shade.B = 0x3F;
391 shade.A = 0;
392
393 DDrConsole_PrintColored(args[0].value_str32, 1, color, shade);
394 return 0;
395}
396
397
[474]398uint16_t ONICALL bsl_nametoindex(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[446]399{
[481]400
[446]401 ret->type = sl_int32;
402 ret->value_int32 = DDrGetCharacterIndexFromName(args[0].value_str32);
[481]403
[446]404 return 0;
405}
[450]406
[474]407uint16_t ONICALL bsl_getactiveoffset(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[450]408{
409 DDrConsole_PrintF("Character: 0x%x",(int)ONgGameState + 0x1260);
410 DDrConsole_PrintF("ActiveChar: 0x%x",(int)ONrGetActiveCharacter((void*)((int)ONgGameState + 0x1260)));
411 return 0;
412}
[470]413typedef struct {
414char Name[16];
415int Bit;
416} KeyBit;
417
418KeyBit Actions1[32] = {
419 {"Escape", Action_Escape},
420 {"Console", Action_Console},
421 {"PauseScreen", Action_PauseScreen},
422 {"Cutscene1", Action_Cutscene_1 },
423 {"Cutscene2", Action_Cutscene_2 },
424 {"F4", Action_F4 },
425 {"F5", Action_F5 },
426 {"F6", Action_F6 },
427 {"F7", Action_F7 },
428 {"F8", Action_F8 },
429 {"StartRecorn", Action_StartRecord },
430 {"StopRecord", Action_StopRecord },
431 {"PlayRecord", Action_PlayRecord },
432 {"F12", Action_F12 },
433 {"Unknown1", Action_Unknown1 },
434 {"LookMode", Action_LookMode },
435 {"Screenshot", Action_Screenshot },
436 {"Unknown2", Action_Unknown2 },
437 {"Unknown3", Action_Unknown3 },
438 {"Unknown4", Action_Unknown4 },
439 {"Unknown5", Action_Unknown5 },
440 {"Forward", Action_Forward },
441 {"Backward", Action_Backward },
442 {"TurnLeft", Action_TurnLeft },
443 {"TurnRight", Action_TurnRight },
444 {"StepLeft", Action_StepLeft },
445 {"StepRight", Action_StepRight },
446 {"Jump", Action_Jump },
447 {"Crouch", Action_Crouch },
448 {"Punch",Action_Punch },
449 {"Kick", Action_Kick },
450 {"Block", Action_Block }
451};
452
453KeyBit Actions2[9] = {
454 {"Walk", Action2_Walk},
455 {"Action", Action2_Action},
456 {"Hypo", Action2_Hypo},
457 {"Reload", Action2_Reload },
458 {"Swap", Action2_Swap },
459 {"Drop", Action2_Drop },
460 {"Fire1", Action2_Fire1 },
461 {"Fire2", Action2_Fire2 },
462 {"Fire3", Action2_Fire3 }
463};
[474]464uint16_t ONICALL bsl_holdkey(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[470]465 {
466 int index;
[481]467
468 if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
[470]469 else index = args[0].value_int32;
[481]470
[470]471 Character* Chr = ONgGameState + 0x1260;
472 ActiveCharacter* Active = (ActiveCharacter*)ONrGetActiveCharacter(&Chr[index]);
473 if ((int)Active == 0) return 1;
474 int i = 2;
475 int j = 0;
476 int Input1 = 0;
477 int Input2 = 0;
[481]478 for(i = 1; i < numargs - 1; i++) {
[470]479 for(j = 0; j < 32; j++) {
[481]480 if(!strcmp(args[i].value_str32, Actions1[j].Name)) {
481 Input1 = Input1 | Actions1[j].Bit;
482 }
[470]483 }
484 for(j = 0; j < 9; j++) {
[481]485 if(!strcmp(args[i].value_str32, Actions2[j].Name)) {
486 Input2 = Input2 | Actions2[j].Bit;
487 }
[470]488 }
489 }
[481]490 Active->Input.Current.Actions1 = Active->Input.Current.Actions1 | Input1;
491 Active->Input.Current.Actions2 = Active->Input.Current.Actions1 | Input2;
492 if( Input1 + Input2 == 0 ) {
493 DDrConsole_PrintF("Func \"%s\", File \"%s\", Line %d: semantic error, \"%s\": No valid keys given.", callinfo->name, callinfo->calllocation, callinfo->linenumber, callinfo->name);
494 return 0;
495 }
496 if ( args[numargs - 1].value_int32 <= 0) {
497 return 0;
498 }
499 else {
500 args[numargs - 1].value_int32 -= 1;
501 *dontuse2 = 1;
502 *dontuse1 = 1;
503 }
[470]504 return 0;
505}
506
[474]507uint16_t ONICALL bsl_isheld(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[470]508 {
509// int index;
510// if (numargs < 4) index = 0;
511// else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
512// else index = args[0].value_int32;
513
514// Character* Chr = ONgGameState + 0x1260;
515// ActiveCharacter* Active = (ActiveCharacter*)ONrGetActiveCharacter(&Chr[index]);
516// if ((int)Active == 0) return 1;
517 int i = 2;
518 int j = 0;
519 int Input1 = 0;
520 int Input2 = 0;
521 for(i = 0; i < numargs; i++) {
522 for(j = 0; j < 32; j++) {
523 //DDrConsole_PrintF("Testing %s against %s 0x%x", args[i].value_str32, Actions1[j].Name, Actions1[j].Bit);
524 if(!strcmp(args[i].value_str32, Actions1[j].Name)) {
525 Input1 = Input1 | Actions1[j].Bit;
526 //DDrConsole_PrintF("Success!");
527 }
528
529 }
530 for(j = 0; j < 9; j++) {
531 if(!strcmp(args[i].value_str32, Actions2[j].Name)) Input2 = Input2 | Actions2[j].Bit;
532
533 }
534 }
535 //DDrConsole_PrintF("Testing: 0x%x Input: 0x%x",Input1, *(int*)(ONgGameState + 0xB8 + 0x10));
536 ret->value_int32 = 0;
537 ret->type = sl_int32;
538 if ( ((*(int*)(ONgGameState + 0xB8 + 0x10) & Input1) == Input1) && ((*(int*)(ONgGameState + 0xB8 + 0x14) & Input2) == Input2)) ret->value_int32 = 1;
539 return 0;
540}
541
542uint16_t ONICALL bsl_waitforkey(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
543 {
544// int index;
545// if (numargs < 4) index = 0;
546// else if (args[0].type == sl_str32) index = DDrGetCharacterIndexFromName(args[0].value_str32);
547// else index = args[0].value_int32;
548
549// Character* Chr = ONgGameState + 0x1260;
550// ActiveCharacter* Active = (ActiveCharacter*)ONrGetActiveCharacter(&Chr[index]);
551// if ((int)Active == 0) return 1;
552 int i = 2;
553 int j = 0;
554 int Input1 = 0;
555 int Input2 = 0;
556 for(i = 0; i < numargs; i++) {
557 for(j = 0; j < 32; j++) {
558 //DDrConsole_PrintF("Testing %s against %s 0x%x", args[i].value_str32, Actions1[j].Name, Actions1[j].Bit);
559 if(!strcmp(args[i].value_str32, Actions1[j].Name)) {
560 Input1 = Input1 | Actions1[j].Bit;
561 //DDrConsole_PrintF("Success!");
562 }
563
564 }
565 for(j = 0; j < 9; j++) {
566 if(!strcmp(args[i].value_str32, Actions2[j].Name)) Input2 = Input2 | Actions2[j].Bit;
567
568 }
569 }
570 //DDrConsole_PrintF("Waiting...");
571 if ( ((*(int*)(ONgGameState + 0xB8 + 0x10) & Input1) == Input1) && ((*(int*)(ONgGameState + 0xB8 + 0x14) & Input2) == Input2)) {
572 }
573 else {
574 //else (int)*ret = 1;
575 *dontuse2 = 1;
576 *dontuse1 = 1;
577 }
[444]578/*
[470]579 __asm__(
580 "movl 0x10(%esp), %edx\n\t"
581 "movl $1,(%eax)\n\t"
582 );
583 //ret->type = sl_void
584*/ return 0;
585}
586
587/*
[474]588uint16_t ONICALL bsl_sprintf(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[441]589{
590 if (numargs < 2)
591 return 1;
[445]592
[441]593 char output[255];
[444]594 int i;
595 for(i = 1; i < numargs; i++) {
596 sprintf(output, args[0].value_str32, args[i].value_str32);
[441]597 }
598
599 ret->value_str32 = output;
600 ret->type = sl_str32;
601 return 0;
602}
[444]603*/
[474]604uint16_t ONICALL bsl_sprintf(sl_callinfo* callinfo, uint32_t numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[440]605{
[445]606 if (numargs < 1 || args[0].type != sl_str32)
607 {
608 DDrConsole_PrintF("Func \"%s\", File \"%s\", Line %d: semantic error, \"%s\": parameter list does not match: format:string arg1 arg2 ...", callinfo->name, callinfo->calllocation, callinfo->linenumber, callinfo->name);
609 return 0;
610 }
611
612 if (!args[0].value_str32)
613 args[0].value_str32 = "";
614
[444]615 int ffi_ret;
616 char* str = NULL;
617 int size = 0;
[440]618
[443]619 ffi_cif cif;
[444]620 ffi_type* ffi_args[256];
621 void* values[256];
[440]622
[443]623 ffi_args[0] = &ffi_type_pointer;
[444]624 values[0] = &str;
[443]625 ffi_args[1] = &ffi_type_uint32;
[444]626 values[1] = &size;
[443]627
628 int i;
629 for(i = 2; i < numargs + 2; i ++)
[440]630 {
[444]631 if (args[i - 2].type == sl_float)
632 {
633 float value_float = args[i - 2].value_float;
634 double* value_double = (double*)&(args[i - 2]);
635 *value_double = value_float;
636
637 ffi_args[i] = &ffi_type_double;
638 values[i] = value_double;
639 }
640 else
641 {
642 ffi_args[i] = &ffi_type_pointer;
643 values[i] = &(args[i - 2].value);
644 }
[440]645 }
646
[444]647 if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, i, &ffi_type_sint32, ffi_args) != FFI_OK)
[445]648 return 1;
[443]649 ffi_call(&cif, (void*)snprintf, (void*)&ffi_ret, values);
[444]650 str = malloc(ffi_ret + 1);
651 size = ffi_ret + 1;
652 ffi_call(&cif, (void*)snprintf, (void*)&ffi_ret, values);
653 ret->value_str32 = str;
[443]654 ret->type = sl_str32;
[440]655 return 0;
656}
657
[447]658// Widescreen patch for talking heads.
[474]659uint16_t ONICALL cinematic_start_patch(sl_callinfo* callinfo, unsigned int numargs, sl_arg args[], int* dontuse1, int* dontuse2, sl_arg* ret)
[447]660{
661 args[1].value_int32 = (double)args[1].value_int32 / (double)(gl->DisplayMode.Width) * (4.0 / 3.0 * (double)(gl->DisplayMode.Height));
662 return ((sl_func)(OniExe + 0x000f3830))(callinfo, numargs, args, dontuse1, dontuse2, ret);
663}
664
[451]665bool ini_inbsl = false;
666bool SLrIniCallback(char* section, bool newsection, char* name, char* value)
667{
668 if (newsection && !stricmp(section, "bsl"))
669 ini_inbsl = true;
670
671 if (ini_inbsl)
672 {
673 bool isptr = false;
674 sl_type bsl_type;
675
676 if (value[0] == 'p' && value[1] == 't' && value[2] == 'r' && value[3] == ':')
677 {
678 isptr = true;
679 value += 4;
680 }
681
682 char* type = value;
683
684 for (; *type; type++)
685 if (*type == ':')
686 {
687 *type = '\0';
688 type++;
689 break;
690 }
691
692 if (!*type)
693 DDrStartupMessage("badly formed bsl definition for \"%s\"", name);
694
695 if (!strcmp(type, "int"))
696 bsl_type = sl_int32;
697 else if (!strcmp(type, "string"))
698 bsl_type = sl_str32;
699 else if (!strcmp(type, "float"))
700 bsl_type = sl_float;
701 else if (!strcmp(type, "bool"))
702 bsl_type = sl_bool;
703 else
704 {
705 DDrStartupMessage("unknown type in bsl definition for \"%s\"", name);
706 return true;
707 }
708
709 if (isptr)
710 {
711 char* bsl_var = malloc(strlen(name) + 1);
712 memcpy(bsl_var, name, strlen(name) + 1);
713 switch (bsl_type)
714 {
715 case sl_int32:
716 SLrGlobalVariable_Register_Int32(bsl_var, "see daodan.ini", (int32_t*)(uint32_t)inifile_parseint(value, false));
717 break;
718 case sl_float:
719 SLrGlobalVariable_Register_Float(bsl_var, "see daodan.ini", (float*)(uint32_t)inifile_parseint(value, false));
720 break;
721 default:
722 break;
723 }
724 }
725 else
726 {
727 char* bsl_var = malloc(strlen(name) + 1 + sizeof(int32_t));
728 int32_t* bsl_val = (int32_t*)bsl_var;
729 bsl_var += sizeof(int32_t);
730 memcpy(bsl_var, name, strlen(name) + 1);
731
732 switch (bsl_type)
733 {
734 case sl_int32:
735 *bsl_val = inifile_parseint(value, false);
736 SLrGlobalVariable_Register_Int32(bsl_var, "see daodan.ini", bsl_val);
737 break;
738 case sl_float:
739 break;
740 default:
741 break;
742 }
743 }
744 }
745 return true;
746}
747
748void SLrConfig()
749{
750 DDrStartupMessage("re-parsing daodan.ini for bsl...");
751 inifile_read("daodan.ini", SLrIniCallback);
752 DDrStartupMessage("finished parsing");
753}
754
[439]755void SLrDaodan_Initalize()
756{
[470]757
758
[484]759 //Calculating the value of the needed offset is much more reliable when the compiler does it for you.
760
761 //TODO: fix moonshadow.
762 Character * Chr = 0;
763 char NoPath = (char)(0x100 - (int)(Chr->ScriptNoPath));
764 const char regen_patch[] =
765 {0x90, 0x90, 0x90, 0x90, 0x90, // mov al, _WPgRegenerationCheat
766 0x90, 0x90, // test al, al
767 0x90, 0x90, // jz short loc_51BB98
768 0x8B, 0x86, NoPath};
769 DDrPatch_Const(OniExe + 0x0011BB64, regen_patch);
770
[451]771 SLrConfig();
[470]772
[439]773 SLrScript_Command_Register_ReturnType("int32mul", "Multiplies two numbers", "n1:int n2:int", sl_int32, bsl_int32mul);
774 SLrScript_Command_Register_ReturnType("mul", "Multiplies two numbers", "[int1:int|float1:float] [int2:int|float2:float]", sl_float, bsl_mul);
775
776 SLrScript_Command_Register_ReturnType("int32div", "Divides two numbers", "n1:int n2:int", sl_int32, bsl_int32div);
777 SLrScript_Command_Register_ReturnType("div", "Divides two numbers", "[int1:int|float1:float] [int2:int|float2:float]", sl_float, bsl_div);
[440]778
[443]779 dsfmt_gv_init_gen_rand((uint32_t)time(NULL));
780 SLrScript_Command_Register_ReturnType("int32rand", "Returns a pseudo-random number between two numbers (inclusive).", "start:int end:int", sl_int32, bsl_int32rand);
781
[446]782 SLrScript_Command_Register_ReturnType("d_getkills","Gets the number of kills a character has", "[ai_name:str | script_id:int]", sl_int32, bsl_getkills);
783 SLrScript_Command_Register_ReturnType("d_getdamage","Gets the amount of damage a character has caused", "[ai_name:string | script_id:int]", sl_int32, bsl_getdamage);
784 SLrScript_Command_Register_ReturnType("d_name","Gets or sets a character's name", "[ai_name:str | script_id:int] [newname:string]", sl_str32, bsl_chrname);
[481]785 SLrScript_Command_Register_ReturnType("d_getindex","Converts a character's name to its index", "ai_name:string", sl_int32, bsl_nametoindex);
[446]786 SLrScript_Command_Register_ReturnType("d_health","Gets or sets a character's health", "[ai_name:str | script_id:int] [newhealth:int]", sl_str32, bsl_health);
[470]787 SLrScript_Command_Register_ReturnType("d_regen","Gets or sets a character's health", "[ai_name:str | script_id:int] [newhealth:int]", sl_str32, bsl_regen);
[446]788 SLrScript_Command_Register_ReturnType("d_maxhealth","Gets or sets a character's maximum health", "[ai_name:str | script_id:int] [newmaxhealth:int] [scalehealth:bool]", sl_str32, bsl_maxhealth);
789 SLrScript_Command_Register_ReturnType("d_powerup","Gets or sets a character's powerups", "ai_name:str|script_id:int powerup:str", sl_int32, bsl_powerup);
[481]790 SLrScript_Command_Register_ReturnType("d_holdkey","Makes a character hold a key", "[ai_name:string | script_id:int] keys frames:int", sl_int32, bsl_holdkey);
791 SLrScript_Command_Register_ReturnType("d_isheld","Checks if player is holding a key", "keys", sl_int32, bsl_isheld);
792 SLrScript_Command_Register_ReturnType("d_location","Returns the X, Y or Z coord of a character", "ai_name:str | script_id:int xyz:string [newlocation:float]", sl_float, bsl_location);
793 SLrScript_Command_Register_ReturnType("d_distance","Returns the distance between two characters", "ai_name:str | script_id:int ai_name:str | script_id:int ", sl_float, bsl_distance);
794 SLrScript_Command_Register_Void("d_waitforkey","Waits for a keypress from the player", "keys", bsl_waitforkey);
[470]795
[481]796 //broken, only works for one damage type.
797 //SLrScript_Command_Register_ReturnType("d_getattacker","Gets the last person to hurt a character", "[ai_name:string | script_id:int]", sl_int32, bsl_getattacker);
[441]798
[481]799 //used for debugging.
800 SLrScript_Command_Register_ReturnType("d_active","Returns a hex offset. ;)", "[ai_name:string | script_id:int]", sl_int32, bsl_getactiveoffset);
[450]801
[445]802 SLrScript_Command_Register_ReturnType("sprintf", "C-style sprintf.", "format:string arg1 arg2 ...", sl_str32, bsl_sprintf);
[451]803
[484]804 SLrScript_Command_Register_ReturnType("st", "prints to console in color", "text:string [color: r b g] [color: r b g]", sl_void, bsl_dprintcolored);
[470]805
[484]806 //Flatline
807 SLrFlatline_Initialize();
808
[447]809}
[451]810
[447]811void SLrDaodan_Patch()
812{
813 DDrPatch_Int32(OniExe + 0x000f3755, (int)cinematic_start_patch);
814}
Note: See TracBrowser for help on using the repository browser.