[567] | 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 |
|
---|
| 22 | uint16_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 |
|
---|
| 29 | uint16_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 |
|
---|
| 49 | uint16_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 | }
|
---|
| 55 | uint16_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 |
|
---|
| 75 | uint16_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 |
|
---|
| 98 | uint16_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 |
|
---|
| 111 | uint16_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 |
|
---|
| 124 | uint16_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 |
|
---|
| 189 | uint16_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 |
|
---|
| 211 | uint16_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.
|
---|
| 242 | uint16_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 | }
|
---|
| 266 | uint16_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 |
|
---|
| 303 | uint16_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 |
|
---|
| 326 | uint16_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 |
|
---|
| 346 | uint16_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 |
|
---|
| 370 | uint16_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 |
|
---|
| 378 | uint16_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 |
|
---|
| 405 | uint16_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 |
|
---|
| 414 | typedef struct {
|
---|
| 415 | char Name[16];
|
---|
| 416 | int Bit;
|
---|
| 417 | } KeyBit;
|
---|
| 418 |
|
---|
| 419 | KeyBit 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 |
|
---|
| 454 | KeyBit 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 | };
|
---|
| 465 | uint16_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;
|
---|
| 478 | Active = ONrGetActiveCharacter(&Chr[index]);
|
---|
| 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 |
|
---|
| 510 | uint16_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 |
|
---|
| 545 | uint16_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 | /*
|
---|
| 594 | uint16_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 | /*
|
---|
| 611 | uint16_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.
|
---|
| 666 | uint16_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 |
|
---|
| 672 | bool ini_inbsl = false;
|
---|
| 673 | bool 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 |
|
---|
| 756 | void SLrConfig()
|
---|
| 757 | {
|
---|
| 758 | DDrStartupMessage("re-parsing daodan.ini for bsl...");
|
---|
| 759 | inifile_read("daodan.ini", SLrIniCallback);
|
---|
| 760 | DDrStartupMessage("finished parsing");
|
---|
| 761 | }
|
---|
| 762 |
|
---|
| 763 | void 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 | }
|
---|
| 774 | void* TSrTest = 0;
|
---|
| 775 | uint16_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 |
|
---|
| 785 | void 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 | 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);
|
---|
| 822 | 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);
|
---|
| 823 | 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);
|
---|
| 824 | 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);
|
---|
| 825 | SLrScript_Command_Register_Void("d_waitforkey","Waits for a keypress from the player", "keys", bsl_waitforkey);
|
---|
| 826 |
|
---|
| 827 | //broken, only works for one damage type.
|
---|
| 828 | //SLrDaodan_Register_ReturnType("d_getattacker","Gets the last person to hurt a character", "[ai_name:string | script_id:int]", sl_int32, bsl_getattacker);
|
---|
| 829 |
|
---|
| 830 | //used for debugging.
|
---|
| 831 | // SLrDaodan_Register_ReturnType("d_active","Returns a hex offset. ;)", "[ai_name:string | script_id:int]", sl_int32, bsl_getactiveoffset);
|
---|
| 832 |
|
---|
| 833 | //SLrDaodan_Register_ReturnType("sprintf", "C-style sprintf.", "format:string arg1 arg2 ...", sl_str32, bsl_sprintf);
|
---|
| 834 |
|
---|
| 835 | SLrScript_Command_Register_ReturnType("st", "prints to console in color", "text:string color1:int color2:int", sl_void, bsl_dprintcolored);
|
---|
| 836 |
|
---|
| 837 | //Flatline
|
---|
| 838 | //#ifdef FLATLINE
|
---|
| 839 | SLrFlatline_Initialize();
|
---|
| 840 | //#endif
|
---|
| 841 | }
|
---|
| 842 |
|
---|
| 843 | void SLrDaodan_Patch()
|
---|
| 844 | {
|
---|
| 845 | DDrPatch_Int32(OniExe + 0x000f3755, (int)cinematic_start_patch);
|
---|
| 846 | }
|
---|