source: Daodan/MSVC/Daodan_BSL.c @ 568

Last change on this file since 568 was 568, checked in by gumby, 11 years ago

Updates

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