| blob | a486f1bfa53a3f9d1faba851afb23fd8222edd40 |
1 /*
2 * OpenBOR - http://www.LavaLit.com
3 * -----------------------------------------------------------------------
4 * Licensed under the BSD licence, see LICENSE in OpenBOR root for details.
5 *
6 * Copyright (c) 2004 - 2011 OpenBOR Team
7 */
9 /* This file include all script methods used by openbor engine
11 Notice: Make sure to null *pretvar when you about to return E_FAIL,
12 Or the engine might crash.
14 Notice: Every new ScriptVariant must be initialized when you first alloc it by
15 ScriptVariant_Init immediately, memset it all to zero should also work by now,
16 unless VT_EMPTY is changed.
18 If you want to reset a ScriptVariant to empty, you must use ScriptVariant_Clear instead.
19 ScriptVariant_Init or memset must be called only ONCE, later you should use ScriptVariant_Clear.
21 Besure to call ScriptVariant_Clear if you want to use free to delete those variants.
23 If you want to copy a ScriptVariant from another, use ScriptVariant_Copy instead of assignment,
24 not because it is faster, but this method is neccessary for string types.
26 If you want to change types of an ScriptVariant, use ScriptVariant_ChangeType, don't change vt directly.
28 */
39 // Define macro for string mapping
40 #define MAPSTRINGS(VAR, LIST, MAXINDEX, FAILMSG) \
41 if(VAR->vt == VT_STR) { \
42 propname = (char*)StrCache_Get(VAR->strVal); \
43 prop = searchList(LIST, propname, MAXINDEX); \
44 if(prop >= 0) { \
45 ScriptVariant_ChangeType(VAR, VT_INTEGER); \
46 VAR->lVal = prop; \
47 } else { printf(FAILMSG, propname); } \
48 }
71 List theFunctionList;
85 //this function should be called before all script methods, for once
98 }
99 }
100 /*
101 for(i=0; i<max_global_vars; i++)
102 {
103 global_var_list[i] = malloc(sizeof(s_variantnode));
104 assert(global_var_list[i] != NULL);
105 memset(global_var_list[i], 0, sizeof(s_variantnode));
106 } */
116 }
121 }
123 //this function should only be called when the engine is shutting down
127 // dump all un-freed variants
134 }
136 // clear the global list
141 //free(global_var_list[i]);
142 }
143 //global_var_list[i] = NULL;
144 }
147 }
152 }
158 }
170 }
173 }
175 // local function
181 // search the name
187 {
188 /// re-adjust bounds, swap with last node
193 }
194 max_global_var_index--;
195 }
197 }
198 }
201 // all slots are taken
204 // so out of bounds, find another slot
211 }
216 }
229 }
230 max_global_var_index--;
231 }
232 }
236 }
246 if(global_var_list[i]->owner == pcurrentscript && strcmp(theName, global_var_list[i]->key) == 0)
248 }
251 }
257 }
267 }
269 }
279 }
280 }
288 }
290 //safe copy method
299 }
308 }
311 }
316 //if it is the owner, free the interpreter
321 }
328 }
330 //append part of the script
331 //Because the script might not be initialized in 1 time.
336 //printf(text);
342 }
344 //return name of function from pointer to function
548 else
550 }
552 //return string mapping function corresponding to a given function
584 else
586 }
588 /* Replace string constants with enum constants at compile time to speed up
589 script execution. */
594 //ScriptVariant* var;
602 params =
607 // Get the pointer to the correct mapstrings function, if one exists.
610 // Call the mapstrings function.
613 // Find the instruction containing each constant and update its value.
616 pInstruction2 =
623 }
624 }
627 }
628 }
629 }
630 }
633 }
635 // replaces the entire instruction list with a new instruction list after optimization
639 Instruction **oldList = (Instruction **) pInterpreter->theSolidListOfInstructionList->solidlist;
652 }
653 }
654 // if the jump target isn't found, it must have been removed in an optimization - whoops!
660 }
661 }
662 }
664 // replace new list with old list
670 }
672 // prints lots of debugging stuff about optimizations that can be made
688 pInstruction2 =
691 numRefs++;
692 }
693 //printf("Variable declared, %i references\n", numRefs, pInstruction->theToken->theSource);
694 //printf("DATA (theVal=0x%08X, theRef=0x%08X)\n", pInstruction->theVal, pInstruction->theRef);
700 }
703 #define ISCONST(x) ((x) && ((x->OpCode==CONSTINT)||(x->OpCode==CONSTSTR)||(x->OpCode==CONSTDBL)))
704 // Look for constant binary ops
715 }
722 //printf("ADD 0x%08X: %s + %s = %s\n", pInstruction, buf, buf2, buf3);
723 }
724 #if 0
731 #endif
732 }
733 #undef ISCONST
734 }
736 // replace old instruction list with optimized one (TODO: enable when this function actually does optimizations)
737 //Script_ReplaceInstructionList(pinterpreter, &newInstructionList);
738 }
740 // detect unused functions in scripts (to save memory)
745 List newInstructionList;
753 // detect function declarations (FIXME: should have an opcode for function declarations other than NOOP)
758 // find all calls to this function
762 numCalls++;
763 }
767 while(instructionList[i]->OpCode != RET) // skip function without adding to new instruction list
768 {
774 }
783 //if(pInstruction->theToken) {free(pInstruction->theToken); pInstruction->theToken=NULL;} // TODO: move somewhere else
784 }
789 }
791 //should be called only once after parsing text
796 //Interpreter_OutputPCode(pscript->pinterpreter, "code");
801 }
806 }
807 //result = Script_DetectUnusedFunctions(pscript);
808 //if(!result) {Script_Clear(pscript, 1);shutdown(1, "Script optimization failed!\n");}
809 //Script_LowerConstants(pscript);
812 }
818 }
820 //execute the script
832 }
834 #ifndef COMPILED_SCRIPT
835 //this method is for debug purpose
840 }
841 #endif
843 //used by Script_Global_Init
845 //printf("Loading system script functions....");
846 //load system functions if we need
862 List_InsertAfter(&theFunctionList, (void *) openbor_changesystemvariant, "changeopenborvariant");
875 List_InsertAfter(&theFunctionList, (void *) openbor_changeplayerproperty, "changeplayerproperty");
876 List_InsertAfter(&theFunctionList, (void *) openbor_changeentityproperty, "changeentityproperty");
901 List_InsertAfter(&theFunctionList, (void *) openbor_changetextobjproperty, "changetextobjproperty");
905 List_InsertAfter(&theFunctionList, (void *) openbor_changebglayerproperty, "changebglayerproperty");
907 List_InsertAfter(&theFunctionList, (void *) openbor_changefglayerproperty, "changefglayerproperty");
909 List_InsertAfter(&theFunctionList, (void *) openbor_changelevelproperty, "changelevelproperty");
915 List_InsertAfter(&theFunctionList, (void *) openbor_getfilestreamargument, "getfilestreamargument");
917 List_InsertAfter(&theFunctionList, (void *) openbor_getfilestreamposition, "getfilestreamposition");
918 List_InsertAfter(&theFunctionList, (void *) openbor_setfilestreamposition, "setfilestreamposition");
948 List_InsertAfter(&theFunctionList, (void *) openbor_changemodelproperty, "changemodelproperty");
950 //printf("Done!\n");
952 }
954 //////////////////////////////////////////////////////////
955 //////////// system functions
956 //////////////////////////////////////////////////////////
957 //isempty(var);
967 }
969 //NULL();
974 }
979 }
981 //getglobalvar(varname);
987 }
992 }
996 else
999 }
1001 //maxglobalvarindex();
1002 s32 system_maxglobalvarindex(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1006 }
1008 //setglobalvar(varname, value);
1013 }
1018 }
1021 (*pretvar)->lVal = (s32) Script_Set_Global_Variant(StrCache_Get(varlist[0]->strVal), (varlist[1]));
1024 }
1026 //getlocalvar(varname);
1033 }
1038 }
1042 else
1045 }
1047 //setlocalvar(varname, value);
1052 }
1057 }
1060 (*pretvar)->lVal = (s32) Script_Set_Local_Variant(StrCache_Get(varlist[0]->strVal), varlist[1]);
1063 }
1065 //clearlocalvar();
1070 }
1072 //clearglobalvar();
1073 s32 system_clearglobalvar(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1077 }
1079 //clearindexedvar();
1080 s32 system_clearindexedvar(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1086 }
1088 //free();
1097 }
1099 }
1101 //////////////////////////////////////////////////////////
1102 //////////// openbor functions
1103 //////////////////////////////////////////////////////////
1105 // ===== openborvariant =====
1110 // This enum is replicated in getsyspropertybyindex in openbor.c. If you
1111 // change one, you must change the other as well!!!!
1113 _sv_branchname,
1114 _sv_count_enemies,
1115 _sv_count_entities,
1116 _sv_count_npcs,
1117 _sv_count_players,
1118 _sv_current_level,
1119 _sv_current_palette,
1120 _sv_current_set,
1121 _sv_current_stage,
1122 _sv_elapsed_time,
1124 _sv_ent_max,
1125 _sv_game_paused,
1126 _sv_game_speed,
1127 _sv_gfx_y_offset,
1128 _sv_hResolution,
1129 _sv_in_level,
1130 _sv_in_selectscreen,
1131 _sv_lasthita,
1132 _sv_lasthitc,
1133 _sv_lasthitt,
1134 _sv_lasthitx,
1135 _sv_lasthitz,
1136 _sv_levelheight,
1137 _sv_levelwidth,
1138 _sv_lightx,
1139 _sv_lightz,
1140 _sv_maxentityvars,
1141 _sv_maxglobalvars,
1142 _sv_maxindexedvars,
1143 _sv_maxplayers,
1144 _sv_maxscriptvars,
1145 _sv_models_cached,
1146 _sv_models_loaded,
1147 _sv_numpalettes,
1148 _sv_pixelformat,
1149 _sv_player,
1150 _sv_player1,
1151 _sv_player2,
1152 _sv_player3,
1153 _sv_player4,
1154 _sv_player_max_z,
1155 _sv_player_min_z,
1156 _sv_shadowalpha,
1157 _sv_shadowcolor,
1158 _sv_slowmotion,
1159 _sv_slowmotion_duration,
1160 _sv_totalram,
1161 _sv_freeram,
1162 _sv_usedram,
1163 _sv_vResolution,
1164 _sv_xpos,
1165 _sv_ypos,
1166 _sv_the_end,
1167 };
1169 // arranged list, for searching
1223 };
1225 MAPSTRINGS(varlist[0], proplist, _sv_the_end, "openborvariant: System variable name not found: '%s'\n");
1226 }
1228 //sample function, used for getting a system variant
1229 //openborvariant(varname);
1230 s32 openbor_systemvariant(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1231 //used for getting the index from the enum of properties
1233 //the paramCount used for checking.
1234 //check it first so the engine wont crash if the list is empty
1237 //call this function's mapstrings function to map string constants to enum values
1239 //the variant name should be here
1240 //you can check the argument type if you like
1243 else
1245 ///////these should be your get method, ///////
1249 }
1250 //else if
1251 //////////////////////////////////////////////
1252 systemvariant_error:
1254 // we have finshed, so return
1256 }
1259 // ===== changeopenborvariant =====
1264 // This enum is replicated in changesyspropertybyindex in openbor.c. If you
1265 // change one, you must change the other as well!!!!
1267 _csv_blockade,
1268 _csv_elapsed_time,
1269 _csv_lasthita,
1270 _csv_lasthitc,
1271 _csv_lasthitt,
1272 _csv_lasthitx,
1273 _csv_lasthitz,
1274 _csv_levelpos,
1275 _csv_scrollmaxz,
1276 _csv_scrollminz,
1277 _csv_slowmotion,
1278 _csv_slowmotion_duration,
1279 _csv_smartbomber,
1280 _csv_textbox,
1281 _csv_xpos,
1282 _csv_ypos,
1283 _csv_the_end,
1284 };
1286 // arranged list, for searching
1304 };
1306 MAPSTRINGS(varlist[0], proplist, _csv_the_end, "changeopenborvariant: System variable name not found: '%s'\n");
1307 }
1309 //used for changing a system variant
1310 //changeopenborvariant(varname, value);
1311 s32 openbor_changesystemvariant(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1312 //used for getting the enum constant corresponding to the desired variable
1314 //reference to the arguments
1316 //the paramCount used for checking.
1317 //check it first so the engine wont crash if the list is empty
1320 // map string constants to enum constants for speed
1322 //get the 1st argument
1324 //the variant name should be here
1325 //you can check the argument type if you like
1328 else
1333 }
1334 changesystemvariant_error:
1336 // we have finshed, so return
1339 }
1341 // use font_printf to draw string
1342 //drawstring(x, y, font, string, z);
1355 }
1365 drawstring_error:
1366 printf
1367 ("First 3 values must be integer values and 4th value a string: drawstring(int x, int y, int font, value)\n");
1369 }
1371 //use screen_printf
1372 //drawstringtoscreen(screen, x, y, font, string);
1373 s32 openbor_drawstringtoscreen(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1392 }
1398 drawstring_error:
1399 printf
1400 ("Function needs a valid screen handle, 3 integers and a string value: drawstringtoscreen(screen, int font, value)\n");
1402 }
1404 // debug purpose
1405 //log(string);
1417 drawstring_error:
1420 }
1422 //drawbox(x, y, width, height, z, color, lut);
1434 }
1444 }
1445 spriteq_add_box((int) value[0], (int) value[1], (int) value[2], (int) value[3], (int) value[4], (int) value[5],
1446 l);
1450 drawbox_error:
1451 printf
1452 ("Function requires 6 integer values: drawbox(int x, int y, int width, int height, int z, int color, int lut)\n");
1454 }
1456 //drawboxtoscreen(screen, x, y, width, height, color, lut);
1457 s32 openbor_drawboxtoscreen(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1474 }
1484 }
1490 drawbox16((int) value[0], (int) value[1], (int) value[2], (int) value[3], (int) value[4], s, l);
1493 drawbox32((int) value[0], (int) value[1], (int) value[2], (int) value[3], (int) value[4], s, l);
1495 }
1499 drawbox_error:
1500 printf
1501 ("Function requires a screen handle and 5 integer values, 7th integer value is optional: drawboxtoscreen(screen, int x, int y, int width, int height, int color, int lut)\n");
1503 }
1505 //drawline(x1, y1, x2, y2, z, color, lut);
1517 }
1527 }
1528 spriteq_add_line((int) value[0], (int) value[1], (int) value[2], (int) value[3], (int) value[4], (int) value[5],
1529 l);
1533 drawline_error:
1534 printf
1535 ("Function requires 6 integer values, 7th integer value is optional: drawline(int x1, int y1, int x2, int y2, int z, int color, int lut)\n");
1537 }
1539 //drawlinetoscreen(screen, x1, y1, x2, y2, color, lut);
1540 s32 openbor_drawlinetoscreen(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1557 }
1567 }
1578 }
1581 drawline_error:
1582 printf
1583 ("Function requires a screen handle and 5 integer values, 7th integer value is optional: drawlinetoscreen(screen, int x1, int y1, int x2, int y2, int color, int lut)\n");
1585 }
1587 //drawsprite(sprite, x, y, z, sortid);
1607 }
1609 spriteq_add_frame((int) value[0], (int) value[1], (int) value[2], spr, &drawmethod, (int) value[3]);
1613 drawsprite_error:
1614 printf
1615 ("Function requires a valid sprite handle 3 integer values, 5th integer value is optional: drawsprite(sprite, int x, int y, int z, int sortid)\n");
1617 }
1619 //drawspritetoscreen(sprite, screen, x, y);
1620 s32 openbor_drawspritetoscreen(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1644 }
1650 drawsprite_error:
1651 printf
1652 ("Function requires a valid sprite handle, a valid screen handle and 2 integer values: drawspritetoscreen(sprite, screen, int x, int y)\n");
1654 }
1656 //drawdot(x, y, z, color, lut);
1668 }
1678 }
1683 drawdot_error:
1684 printf
1685 ("Function requires 4 integer values, 5th integer value is optional: drawdot(int x, int y, int z, int color, int lut)\n");
1687 }
1689 //drawdottoscreen(screen, x, y, color, lut);
1690 s32 openbor_drawdottoscreen(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1707 }
1717 }
1728 }
1732 drawdot_error:
1733 printf
1734 ("Function requires a screen handle and 3 integer values, 5th integer value is optional: dottoscreen(screen, int x, int y, int color, int lut)\n");
1736 }
1739 //drawscreen(screen, x, y, z, lut);
1744 s_drawmethod screenmethod;
1758 }
1768 }
1775 }
1780 drawscreen_error:
1781 printf
1782 ("Function requires a screen handle and 3 integer values, 5th integer value is optional: drawscreen(screen, int x, int y, int z, int lut)\n");
1784 }
1786 //getindexedvar(int index);
1787 s32 openbor_getindexedvar(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1788 s32 ind;
1793 }
1801 }
1809 }
1811 //setindexedvar(int index, var);
1812 s32 openbor_setindexedvar(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
1813 s32 ind;
1818 }
1824 }
1831 }
1837 }
1839 //getscriptvar(int index);
1841 s32 ind;
1846 }
1852 }
1862 }
1864 //setscriptvar(int index, var);
1866 s32 ind;
1871 }
1877 }
1884 }
1890 }
1892 //getentityvar(entity, int index);
1895 s32 ind;
1901 }
1912 printf
1913 ("Function's 1st argument must be a valid entity handle value or empty value: getentityvar(entity, int index)\n");
1916 }
1924 }
1932 }
1934 //setentityvar(int index, var);
1937 s32 ind;
1943 }
1955 printf
1956 ("Function's 1st argument must be a valid entity handle value or empty value: setentityvar(entity, int index, var)\n");
1959 }
1964 printf("Function's 2nd argument must be a numberic value: setentityvar(entity, int index, var)\n");
1967 }
1976 }
1978 //strinfirst(char string, char search_string);
1985 }
1990 printf
1991 ("\n Error, strinfirst({string}, {search string}): Strinfirst must be passed valid {string} and {search string}. \n");
1992 }
1994 tempstr = strstr((char *) StrCache_Get(varlist[0]->strVal), (char *) StrCache_Get(varlist[1]->strVal));
2002 }
2004 }
2006 //strinlast(char string, char search_string);
2013 }
2018 printf
2019 ("\n Error, strinlast({string}, {search string}): Strinlast must be passed valid {string} and {search string}. \n");
2020 }
2030 }
2032 }
2034 //strleft(char string, int i);
2041 }
2043 printf
2044 ("\n Error, strleft({string}, {characters}): Invalid or missing parameter. Strleft must be passed valid {string} and number of {characters}.\n");
2045 }
2056 }
2059 }
2061 //strlength(char string);
2066 }
2071 printf
2072 ("Error, strlength({string}): Invalid or missing parameter. Strlength must be passed a valid {string}.\n");
2073 }
2078 }
2080 //strright(char string, int i);
2087 }
2090 printf
2091 ("\n Error, strright({string}, {characters}): Invalid or missing parameter. Strright must be passed valid {string} and number of {characters}.\n");
2092 }
2103 }
2106 }
2108 s32 openbor_getmodelproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
2114 }
2117 printf
2118 ("\n Error, getmodelproperty({model}, {property}): Invalid or missing parameter. Getmodelproperty must be passed valid {model} and {property} indexes.\n");
2119 }
2125 {
2129 }
2131 {
2134 }
2136 {
2140 }
2142 {
2146 }
2148 {
2152 }
2153 }
2156 }
2158 s32 openbor_changemodelproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
2160 s32 ltemp;
2165 }
2168 printf
2169 ("\n Error, changemodelproperty({model}, {property}, {value}): Invalid or missing parameter. Changemodelproperty must be passed valid {model}, {property} and {value}.\n");
2170 }
2176 {
2177 /*
2178 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[2], <emp)))
2179 model_cache[iArg].loadflag = (int)ltemp;
2180 else (*pretvar)->lVal = (s32)0;
2181 break;
2182 */
2183 }
2185 {
2186 /*
2187 if(varlist[2]->vt != VT_STR)
2188 {
2189 printf("You must give a string value for {value}.\n");
2190 goto changeentityproperty_error;
2191 }
2192 strcpy(model_cache[iArg].model, (char*)StrCache_Get(varlist[2]->strVal));
2193 (*pretvar)->lVal = (s32)1;
2194 break;
2195 */
2196 }
2198 {
2199 /*
2200 if(varlist[2]->vt != VT_STR)
2201 {
2202 printf("You must give a string value for {value}.\n");
2203 goto changeentityproperty_error;
2204 }
2205 strcpy(model_cache[iArg].name, (char*)StrCache_Get(varlist[2]->strVal));
2206 (*pretvar)->lVal = (s32)1;
2207 break;
2208 */
2209 }
2211 {
2212 /*
2213 if(varlist[2]->vt != VT_STR)
2214 {
2215 printf("You must give a string value for {value}.\n");
2216 goto changeentityproperty_error;
2217 }
2218 strcpy(model_cache[iArg].path, (char*)StrCache_Get(varlist[2]->strVal));
2219 (*pretvar)->lVal = (s32)1;
2220 break;
2221 */
2222 }
2224 {
2227 else
2230 }
2231 }
2234 }
2236 // ===== getentityproperty =====
2238 _gep_a,
2239 _gep_aggression,
2240 _gep_aiattack,
2241 _gep_aiflag,
2242 _gep_aimove,
2243 _gep_alpha,
2244 _gep_animal,
2245 _gep_animating,
2246 _gep_animation,
2247 _gep_animationid,
2248 _gep_animheight,
2249 _gep_animhits,
2250 _gep_animnum,
2251 _gep_animpos,
2252 _gep_animvalid,
2253 _gep_antigravity,
2254 _gep_attack,
2255 _gep_attacking,
2256 _gep_attackid,
2257 _gep_autokill,
2258 _gep_base,
2259 _gep_bbox,
2260 _gep_blink,
2261 _gep_blockback,
2262 _gep_blockpain,
2263 _gep_bounce,
2264 _gep_chargerate,
2265 _gep_colourmap,
2266 _gep_colourtable,
2267 _gep_damage_on_landing,
2268 _gep_dead,
2269 _gep_defaultmodel,
2270 _gep_defaultname,
2271 _gep_defense,
2272 _gep_detect,
2273 _gep_direction,
2274 _gep_dot,
2275 _gep_dropframe,
2276 _gep_edelay,
2277 _gep_energycost,
2278 _gep_exists,
2279 _gep_falldie,
2280 _gep_flash,
2281 _gep_freezetime,
2282 _gep_frozen,
2283 _gep_gfxshadow,
2284 _gep_grabbing,
2285 _gep_guardpoints,
2286 _gep_health,
2287 _gep_height,
2288 _gep_hitbyid,
2289 _gep_hmapl,
2290 _gep_hmapu,
2291 _gep_icon,
2292 _gep_invincible,
2293 _gep_invinctime,
2294 _gep_jugglepoints,
2295 _gep_knockdowncount,
2296 _gep_komap,
2297 _gep_landframe,
2298 _gep_lifespancountdown,
2299 _gep_link,
2300 _gep_map,
2301 _gep_mapcount,
2302 _gep_mapdefault,
2303 _gep_maxguardpoints,
2304 _gep_maxhealth,
2305 _gep_maxjugglepoints,
2306 _gep_maxmp,
2307 _gep_model,
2308 _gep_mp,
2309 _gep_mpdroprate,
2310 _gep_mprate,
2311 _gep_mpstable,
2312 _gep_mpstableval,
2313 _gep_name,
2314 _gep_nextanim,
2315 _gep_nextthink,
2316 _gep_no_adjust_base,
2317 _gep_noaicontrol,
2318 _gep_nodieblink,
2319 _gep_nodrop,
2320 _gep_nograb,
2321 _gep_nopain,
2322 _gep_offense,
2323 _gep_opponent,
2324 _gep_owner,
2325 _gep_parent,
2326 _gep_path,
2327 _gep_playerindex,
2328 _gep_projectile,
2329 _gep_range,
2330 _gep_running,
2331 _gep_rush_count,
2332 _gep_rush_tally,
2333 _gep_rush_time,
2334 _gep_scroll,
2335 _gep_seal,
2336 _gep_sealtime,
2337 _gep_setlayer,
2338 _gep_spawntype,
2339 _gep_speed,
2340 _gep_sprite,
2341 _gep_stalltime,
2342 _gep_stats,
2343 _gep_staydown,
2344 _gep_staydownatk,
2345 _gep_stealth,
2346 _gep_subentity,
2347 _gep_subject_to_gravity,
2348 _gep_subject_to_hole,
2349 _gep_subject_to_maxz,
2350 _gep_subject_to_minz,
2351 _gep_subject_to_obstacle,
2352 _gep_subject_to_platform,
2353 _gep_subject_to_screen,
2354 _gep_subject_to_wall,
2355 _gep_subtype,
2356 _gep_throwdamage,
2357 _gep_throwdist,
2358 _gep_throwframewait,
2359 _gep_throwheight,
2360 _gep_tosstime,
2361 _gep_tossv,
2362 _gep_type,
2363 _gep_weapent,
2364 _gep_x,
2365 _gep_xdir,
2366 _gep_z,
2367 _gep_zdir,
2368 _gep_the_end,
2369 };
2372 _gep_edelay_cap_max,
2373 _gep_edelay_cap_min,
2374 _gep_edelay_factor,
2375 _gep_edelay_mode,
2376 _gep_edelay_range_max,
2377 _gep_edelay_range_min,
2378 _gep_edelay_the_end,
2380 };
2383 _gep_aiflag_animating,
2384 _gep_aiflag_attacking,
2385 _gep_aiflag_autokill,
2386 _gep_aiflag_blink,
2387 _gep_aiflag_blocking,
2388 _gep_aiflag_charging,
2389 _gep_aiflag_dead,
2390 _gep_aiflag_drop,
2391 _gep_aiflag_falling,
2392 _gep_aiflag_freezetime,
2393 _gep_aiflag_frozen,
2394 _gep_aiflag_getting,
2395 _gep_aiflag_idling,
2396 _gep_aiflag_inpain,
2397 _gep_aiflag_invincible,
2398 _gep_aiflag_jumping,
2399 _gep_aiflag_projectile,
2400 _gep_aiflag_running,
2401 _gep_aiflag_toexplode,
2402 _gep_aiflag_turning,
2403 _gep_aiflag_the_end,
2404 };
2407 _gep_defense_blockpower,
2408 _gep_defense_blockratio,
2409 _gep_defense_blockthreshold,
2410 _gep_defense_blocktype,
2411 _gep_defense_factor,
2412 _gep_defense_knockdown,
2413 _gep_defense_pain,
2414 _gep_defense_the_end,
2415 };
2418 _gep_running_jumpx,
2419 _gep_running_jumpy,
2420 _gep_running_land,
2421 _gep_running_movez,
2422 _gep_running_speed,
2423 _gep_running_the_end,
2424 };
2427 _gep_dot_force,
2428 _gep_dot_mode,
2429 _gep_dot_owner,
2430 _gep_dot_rate,
2431 _gep_dot_time,
2432 _gep_dot_type,
2433 _gep_dot_the_end,
2434 };
2437 _gep_attack_blast,
2438 _gep_attack_blockflash,
2439 _gep_attack_blocksound,
2440 _gep_attack_coords,
2441 _gep_attack_counterattack,
2442 _gep_attack_direction,
2443 _gep_attack_dol,
2444 _gep_attack_dot,
2445 _gep_attack_dotforce,
2446 _gep_attack_dotindex,
2447 _gep_attack_dotrate,
2448 _gep_attack_dottime,
2449 _gep_attack_drop,
2450 _gep_attack_dropv,
2451 _gep_attack_force,
2452 _gep_attack_forcemap,
2453 _gep_attack_freeze,
2454 _gep_attack_freezetime,
2455 _gep_attack_grab,
2456 _gep_attack_grabdistance,
2457 _gep_attack_guardcost,
2458 _gep_attack_hitflash,
2459 _gep_attack_hitsound,
2460 _gep_attack_jugglecost,
2461 _gep_attack_maptime,
2462 _gep_attack_noblock,
2463 _gep_attack_noflash,
2464 _gep_attack_nopain,
2465 _gep_attack_otg,
2466 _gep_attack_pause,
2467 _gep_attack_seal,
2468 _gep_attack_sealtime,
2469 _gep_attack_staydown,
2470 _gep_attack_steal,
2471 _gep_attack_type,
2472 _gep_attack_the_end,
2473 };
2476 _gep_range_amax,
2477 _gep_range_amin,
2478 _gep_range_bmax,
2479 _gep_range_bmin,
2480 _gep_range_xmax,
2481 _gep_range_xmin,
2482 _gep_range_zmax,
2483 _gep_range_zmin,
2484 _gep_range_the_end,
2485 };
2491 // arranged list, for searching
2623 };
2632 };
2655 };
2665 };
2673 };
2682 };
2720 };
2731 };
2736 // map entity properties
2743 // map subproperties of edelay property
2747 }
2748 // map subproperties of aiflag property
2752 }
2753 // map subproperties of defense property
2758 }
2759 }
2760 // map subproperties of running
2764 }
2765 // map subproperties of DOT
2769 }
2770 // map subproperties of Attack
2774 }
2775 // map subproperties of Range
2779 }
2780 }
2782 //getentityproperty(pentity, propname);
2783 s32 openbor_getentityproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
2790 s32 ltemp;
2799 }
2809 }
2817 }
2823 {
2827 }
2829 {
2833 }
2835 {
2839 }
2841 {
2845 }
2847 {
2851 }
2853 {
2857 }
2859 {
2863 }
2865 {
2869 }
2871 {
2875 }
2877 {
2881 }
2883 {
2887 }
2889 {
2893 }
2895 {
2899 }
2901 {
2905 }
2907 {
2911 }
2913 {
2917 }
2919 {
2923 }
2925 {
2929 }
2931 {
2935 }
2937 {
2941 }
2943 {
2947 }
2949 {
2953 }
2955 {
2959 }
2961 {
2965 }
2967 {
2975 }
2977 {
2980 //printf("%d %s %d\n", ent->sortid, ent->name, ent->playerindex);
2982 }
2984 {
2988 }
2990 {
2994 }
2996 {
3003 }
3004 }
3006 }
3008 {
3012 }
3014 {
3018 }
3020 {
3024 }
3026 {
3030 }
3032 {
3037 printf
3038 ("Error, getentityproperty({ent}, 'icon', {type}): {type} parameter missing or invalid. \n {type}: \n 0 = Icon \n 1 = Icondie \n 2 = Iconget \n 3 = Iconmphigh \n 4 = Iconmphalf \n 5 = Iconmplow \n 6 = Iconpain \n 7 = Iconw \n 8 = Iconx \n 9 = Icony \n");
3040 }
3073 }
3084 }
3086 }
3088 {
3092 }
3095 {
3099 }
3101 {
3105 }
3107 {
3111 }
3113 {
3117 }
3119 {
3123 }
3125 {
3129 }
3131 {
3135 }
3137 {
3141 }
3143 {
3147 }
3149 {
3153 }
3155 {
3161 }
3167 {
3170 }
3172 {
3175 }
3177 {
3180 }
3182 {
3185 }
3187 {
3190 }
3192 {
3195 }
3199 }
3201 }
3203 {
3206 printf
3207 ("\n Error, getentityproperty({ent}, 'energycost', {animation}, {argument}): Missing or invalid parameter. \n");
3209 }
3213 if(!validanim(ent, i)) //Bad or missing animation = instant crash, let's validate and pass user friendly error.
3214 {
3215 printf
3216 ("\n Error, getentityproperty({ent}, 'energycost', {animation}, {argument}): {animation} argument invalid. Make sure the animation exists. \n");
3218 }
3223 }
3225 {
3231 }
3235 }
3237 {
3243 }
3247 }
3249 {
3253 }
3255 {
3259 }
3261 {
3265 }
3267 {
3271 }
3273 {
3277 }
3279 {
3283 }
3285 {
3292 }
3296 {
3300 }
3302 {
3306 }
3308 {
3312 }
3314 {
3318 }
3320 {
3324 }
3326 {
3330 }
3332 {
3336 }
3338 {
3342 }
3344 {
3348 }
3350 {
3354 }
3356 {
3360 }
3362 {
3366 }
3368 {
3372 }
3374 {
3378 }
3380 {
3384 }
3386 {
3390 }
3392 {
3396 }
3398 {
3402 }
3404 {
3408 }
3410 {
3414 }
3418 }
3420 }
3422 {
3426 }
3429 {
3433 }
3435 {
3439 }
3441 {
3447 }
3451 }
3453 {
3457 }
3459 {
3463 }
3465 {
3469 }
3471 {
3475 }
3477 {
3481 }
3483 {
3487 }
3489 {
3493 }
3495 {
3499 }
3501 {
3506 printf
3509 }
3514 }
3516 {
3520 }
3522 {
3526 }
3528 {
3532 }
3534 {
3538 }
3540 {
3544 }
3546 {
3550 }
3552 {
3556 }
3558 {
3562 }
3564 {
3568 }
3570 {
3574 }
3576 {
3582 }
3589 }
3594 {
3598 }
3600 {
3604 }
3606 {
3610 }
3612 {
3616 }
3618 {
3622 }
3624 {
3628 }
3630 {
3634 }
3637 }
3639 }
3641 {
3645 }
3647 {
3651 }
3653 {
3657 }
3659 {
3663 }
3665 {
3669 }
3671 {
3675 }
3677 {
3681 }
3683 {
3690 printf
3691 ("\n Error, getentityproperty({ent}, 'bbox', {index}, {animation}, {frame}, {arg}): {index}, {Animation}, {frame}, or {arg} parameter is missing or invalid. \n");
3693 }
3694 //varlist[3]->lval; //bbox index (multiple bbox support).
3700 }
3707 }
3709 {
3714 printf
3715 ("\n Error, getentityproperty({ent}, 'range', {sub property}, {animation}): {Sub property} or {Animation} parameter is missing or invalid. \n");
3717 }
3722 {
3724 }
3762 }
3768 }
3770 {
3775 printf
3776 ("Error, getentityproperty({ent}, 'attack', {sub property}, {index}, {animation}, {frame}): You must give a string name for {sub property}.\n");
3778 }
3783 printf
3784 ("\n Error, getentityproperty({ent}, 'attack', {sub property}, {index}, {animation}, {frame}): {Animation} or {frame} parameter is missing or invalid. \n");
3786 }
3787 //varlist[3]->lval //Attack box index (multiple attack boxes).
3791 if(!validanim(ent, i) || !ent->modeldata.animation[i]->attacks || !ent->modeldata.animation[i]->attacks[tempint]) //Verify animation and active attack on frame.
3792 {
3794 }
3938 }
3940 }
3942 {
3945 printf
3946 ("Error, getentityproperty({ent}, 'flash', {argument}): Missing or invalid parameter. \n {argument}: \n 0 = Flash \n 1 = Noatflash \n 2=bflash \n");
3948 }
3960 }
3964 }
3966 {
3970 }
3972 {
3976 }
3978 {
3982 }
3984 {
3988 }
3990 {
3994 }
3996 {
4002 }
4006 }
4008 {
4012 }
4014 {
4016 {
4019 }
4021 }
4023 {
4025 {
4028 }
4030 }
4032 {
4038 }
4040 {
4042 {
4045 }
4047 }
4049 {
4051 {
4054 }
4056 }
4058 {
4060 {
4063 }
4065 }
4067 {
4069 {
4072 }
4074 }
4076 {
4080 }
4082 {
4086 }
4088 {
4092 }
4094 {
4098 }
4100 {
4104 }
4106 {
4110 }
4112 {
4116 }
4118 {
4122 }
4124 {
4128 }
4130 {
4134 }
4136 {
4140 }
4142 {
4149 printf
4150 ("Incorrect parameters: getentityproperty({ent}, 'stats', {type}, {index}) \n {type}: \n 0 = Model. \n 1 = Entity. \n");
4152 }
4160 }
4165 }
4167 }
4169 }
4171 {
4176 printf
4177 ("Incorrect parameters: getentityproperty({ent}, 'staydown', {type}) \n {type}: \n 0 = Staydown. \n 1 = Staydownatk. \n");
4179 }
4183 }
4185 {
4189 }
4192 {
4196 }
4198 {
4206 }
4210 {
4214 }
4216 {
4220 }
4222 {
4226 }
4228 {
4232 }
4234 {
4238 }
4239 }
4241 }
4243 {
4247 }
4249 {
4253 }
4255 {
4267 }
4270 {
4274 }
4276 {
4280 }
4283 {
4287 }
4289 {
4293 }
4295 {
4299 }
4301 {
4305 }
4307 }
4308 }
4310 {
4314 }
4316 {
4320 }
4322 {
4326 }
4328 //printf("Property name '%s' is not supported by function getentityproperty.\n", propname);
4332 }
4335 }
4337 // ===== changeentityproperty =====
4339 _cep_aggression,
4340 _cep_aiattack,
4341 _cep_aiflag,
4342 _cep_aimove,
4343 _cep_alpha,
4344 _cep_animation,
4345 _cep_animhits,
4346 _cep_animpos,
4347 _cep_antigrab,
4348 _cep_antigravity,
4349 _cep_attacking,
4350 _cep_attackid,
4351 _cep_autokill,
4352 _cep_base,
4353 _cep_blink,
4354 _cep_blockback,
4355 _cep_blockpain,
4356 _cep_bounce,
4357 _cep_candamage,
4358 _cep_combostep,
4359 _cep_colourmap,
4360 _cep_damage_on_landing,
4361 _cep_dead,
4362 _cep_defaultname,
4363 _cep_defense,
4364 _cep_detect,
4365 _cep_direction,
4366 _cep_dot,
4367 _cep_edelay,
4368 _cep_energycost,
4369 _cep_falldie,
4370 _cep_freezetime,
4371 _cep_frozen,
4372 _cep_gfxshadow,
4373 _cep_grabforce,
4374 _cep_guardpoints,
4375 _cep_health,
4376 _cep_hitbyid,
4377 _cep_hmapl,
4378 _cep_hmapu,
4379 _cep_hostile,
4380 _cep_iconposition,
4381 _cep_invincible,
4382 _cep_invinctime,
4383 _cep_jugglepoints,
4384 _cep_komap,
4385 _cep_lifeposition,
4386 _cep_lifespancountdown,
4387 _cep_map,
4388 _cep_maptime,
4389 _cep_maxguardpoints,
4390 _cep_maxhealth,
4391 _cep_maxjugglepoints,
4392 _cep_maxmp,
4393 _cep_model,
4394 _cep_mp,
4395 _cep_mpset,
4396 _cep_name,
4397 _cep_nameposition,
4398 _cep_nextanim,
4399 _cep_nextthink,
4400 _cep_no_adjust_base,
4401 _cep_noaicontrol,
4402 _cep_nodieblink,
4403 _cep_nodrop,
4404 _cep_nograb,
4405 _cep_nopain,
4406 _cep_offense,
4407 _cep_opponent,
4408 _cep_owner,
4409 _cep_parent,
4410 _cep_position,
4411 _cep_projectile,
4412 _cep_projectilehit,
4413 _cep_running,
4414 _cep_rush_count,
4415 _cep_rush_tally,
4416 _cep_rush_time,
4417 _cep_scroll,
4418 _cep_seal,
4419 _cep_sealtime,
4420 _cep_setlayer,
4421 _cep_speed,
4422 _cep_stalltime,
4423 _cep_stats,
4424 _cep_staydown,
4425 _cep_staydownatk,
4426 _cep_stealth,
4427 _cep_subentity,
4428 _cep_subject_to_gravity,
4429 _cep_subject_to_hole,
4430 _cep_subject_to_maxz,
4431 _cep_subject_to_minz,
4432 _cep_subject_to_obstacle,
4433 _cep_subject_to_platform,
4434 _cep_subject_to_screen,
4435 _cep_subject_to_wall,
4436 _cep_takeaction,
4437 _cep_think,
4438 _cep_throwdamage,
4439 _cep_throwdist,
4440 _cep_throwframewait,
4441 _cep_throwheight,
4442 _cep_tosstime,
4443 _cep_trymove,
4444 _cep_type,
4445 _cep_velocity,
4446 _cep_weapon,
4447 _cep_the_end,
4448 };
4451 _cep_ta_bomb_explode,
4452 _cep_ta_common_attack_proc,
4453 _cep_ta_common_block,
4454 _cep_ta_common_drop,
4455 _cep_ta_common_fall,
4456 _cep_ta_common_get,
4457 _cep_ta_common_grab,
4458 _cep_ta_common_grabattack,
4459 _cep_ta_common_grabbed,
4460 _cep_ta_common_jump,
4461 _cep_ta_common_land,
4462 _cep_ta_common_lie,
4463 _cep_ta_common_pain,
4464 _cep_ta_common_prejump,
4465 _cep_ta_common_rise,
4466 _cep_ta_common_spawn,
4467 _cep_ta_common_turn,
4468 _cep_ta_common_vault,
4469 _cep_ta_normal_prepare,
4470 _cep_ta_npc_warp,
4471 _cep_ta_player_blink,
4472 _cep_ta_suicide,
4473 _cep_ta_the_end,
4474 };
4477 _cep_th_common_think,
4478 _cep_th_player_think,
4479 _cep_th_steam_think,
4480 _cep_th_steamer_think,
4481 _cep_th_text_think,
4482 _cep_th_trap_think,
4483 _cep_th_the_end,
4484 };
4487 _cep_hcd_ground,
4488 _cep_hcd_type_enemy,
4489 _cep_hcd_type_npc,
4490 _cep_hcd_type_obstacle,
4491 _cep_hcd_type_player,
4492 _cep_hcd_type_shot,
4493 _cep_hcd_the_end,
4494 };
4497 _cep_aiflag_animating,
4498 _cep_aiflag_attacking,
4499 _cep_aiflag_autokill,
4500 _cep_aiflag_blink,
4501 _cep_aiflag_blocking,
4502 _cep_aiflag_charging,
4503 _cep_aiflag_dead,
4504 _cep_aiflag_drop,
4505 _cep_aiflag_falling,
4506 _cep_aiflag_frozen,
4507 _cep_aiflag_getting,
4508 _cep_aiflag_idling,
4509 _cep_aiflag_inpain,
4510 _cep_aiflag_invincible,
4511 _cep_aiflag_jumping,
4512 _cep_aiflag_projectile,
4513 _cep_aiflag_running,
4514 _cep_aiflag_toexplode,
4515 _cep_aiflag_turning,
4516 _cep_aiflag_the_end,
4517 };
4632 };
4657 };
4666 };
4688 };
4697 };
4702 // property name
4706 // action for takeaction
4710 }
4711 // 2011_03_13, DC: Think sets for think.
4713 MAPSTRINGS(varlist[2], proplist_think, _cep_th_the_end, "Set '%s' is not supported by 'think'.\n");
4714 }
4715 // entity type(s) for hostile, candamage, and projectilehit.
4722 }
4723 }
4724 // AI flag name for aiflag
4728 }
4729 }
4731 //changeentityproperty(pentity, propname, value1[ ,value2, value3, ...]);
4732 s32 openbor_changeentityproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
4741 common_think,
4742 player_think,
4743 steam_think,
4744 steamer_think,
4745 text_think,
4746 trap_think,
4747 };
4749 bomb_explode,
4750 common_attack_proc,
4751 common_block,
4752 common_drop,
4753 common_fall,
4754 common_get,
4755 common_grab,
4756 common_grabattack,
4757 common_grabbed,
4758 common_jump,
4759 common_land,
4760 common_lie,
4761 common_pain,
4762 common_prejump,
4763 common_rise,
4764 common_spawn,
4765 common_turn,
4766 common_vault,
4767 normal_prepare,
4768 npc_warp,
4769 player_blink,
4770 suicide,
4771 };
4775 TYPE_ENEMY,
4776 TYPE_NPC,
4777 TYPE_OBSTACLE,
4778 TYPE_PLAYER,
4779 TYPE_SHOT,
4780 };
4785 }
4794 }
4799 }
4805 }
4811 {
4812 if(varlist[2]->vt == VT_STR) { // not a known action; if it were it would been mapped by mapstrings
4818 }
4819 // otherwise, the parameter is a known action
4823 }
4826 }
4828 {
4829 if(varlist[2]->vt == VT_STR) { // not a known action; if it were it would been mapped by mapstrings
4830 //ent->think = NULL;
4835 }
4836 // otherwise, the parameter is a known action
4840 }
4843 }
4845 {
4849 }
4855 }
4857 {
4862 {
4866 else
4871 }
4872 }
4874 }
4876 {
4882 {
4888 }
4889 }
4892 }
4894 {
4900 {
4906 }
4907 }
4910 }
4913 {
4917 }
4925 }
4931 }
4933 {
4941 }
4944 }
4946 }
4948 {
4954 }
4956 }
4958 {
4966 }
4968 }
4970 {
4976 }
4978 }
4980 {
4988 }
4990 }
4992 {
4996 }
4998 }
5000 {
5004 }
5006 }
5008 {
5012 }
5014 }
5016 {
5020 }
5022 }
5024 {
5028 }
5030 }
5032 {
5036 }
5038 }
5040 {
5044 }
5046 }
5048 {
5052 }
5054 }
5056 {
5060 }
5062 }
5064 {
5068 }
5070 }
5072 {
5076 }
5078 }
5080 {
5084 }
5088 else
5090 }
5092 }
5094 {
5098 }
5100 }
5102 {
5106 }
5108 }
5110 {
5114 }
5116 }
5118 {
5122 }
5124 }
5126 {
5130 }
5132 }
5134 {
5139 }
5141 {
5146 }
5148 {
5152 }
5156 }
5158 {
5162 }
5165 printf
5168 }
5172 }
5174 {
5178 }
5182 else
5184 }
5188 else
5190 }
5192 }
5194 {
5198 }
5200 }
5202 {
5206 }
5208 }
5210 {
5217 else
5219 }
5221 }
5223 {
5227 }
5229 }
5231 {
5235 }
5237 }
5239 {
5243 }
5245 }
5247 {
5251 }
5255 else
5257 }
5261 else
5263 }
5265 }
5267 {
5272 }
5276 else
5278 }
5282 else
5284 }
5288 else
5290 }
5294 else
5296 }
5300 else
5302 }
5306 else
5308 }
5312 else
5314 }
5316 }
5318 {
5323 }
5327 else
5329 }
5331 }
5333 {
5337 }
5339 {
5343 }
5345 {
5349 }
5351 {
5355 }
5357 {
5361 }
5363 {
5367 }
5369 {
5373 }
5375 {
5379 }
5381 {
5385 }
5387 {
5391 }
5393 {
5397 }
5399 {
5403 }
5405 {
5410 }
5416 {
5420 }
5422 {
5426 }
5428 {
5432 }
5434 {
5438 }
5440 {
5444 }
5446 {
5450 }
5452 {
5456 }
5458 {
5462 }
5464 {
5468 }
5470 {
5474 }
5476 {
5480 }
5482 {
5486 }
5488 {
5492 }
5494 {
5498 }
5500 {
5504 }
5506 {
5510 }
5512 {
5516 }
5518 {
5522 }
5524 {
5528 }
5532 }
5534 }
5536 {
5546 }
5548 }
5550 {
5554 }
5556 {
5560 }
5562 }
5564 {
5568 }
5570 {
5574 }
5576 }
5578 {
5582 }
5584 }
5586 {
5590 }
5592 {
5598 }
5600 {
5606 }
5608 {
5614 }
5616 {
5620 }
5622 {
5626 }
5628 }
5630 {
5634 }
5636 }
5638 {
5642 }
5644 }
5646 {
5650 }
5652 }
5654 {
5658 }
5660 }
5662 {
5666 }
5668 }
5670 {
5674 }
5676 }
5678 {
5682 }
5684 }
5686 {
5690 }
5692 }
5694 {
5697 }
5699 {
5702 }
5704 {
5707 }
5709 {
5716 }
5718 {
5722 }
5724 {
5728 }
5730 {
5734 }
5736 {
5739 }
5743 else
5745 }
5747 }
5749 {
5753 }
5755 }
5757 {
5761 }
5763 }
5765 {
5769 }
5771 }
5773 {
5777 }
5779 {
5783 }
5785 {
5789 }
5791 {
5795 }
5797 {
5810 }
5811 }
5812 }
5814 }
5816 {
5820 }
5822 {
5826 }
5828 {
5832 }
5836 }
5837 }
5839 {
5843 }
5845 {
5849 }
5851 {
5855 }
5857 {
5861 }
5865 }
5869 }
5873 }
5877 }
5880 }
5882 {
5886 }
5888 {
5892 }
5894 {
5897 }
5901 }
5905 else
5907 }
5911 else
5913 }
5917 else
5919 }
5923 else
5925 }
5928 }
5930 }
5932 {
5936 }
5940 }
5944 else
5946 }
5950 else
5952 }
5956 else
5958 }
5962 else
5964 }
5966 }
5968 {
5970 printf
5971 ("\n Error, changeentityproperty({ent}, 'energycost', {animation}, {cost}, {mponly}, {disable}): Invalid or missing parameter. \n");
5973 }
5979 }
5982 printf
5983 ("\n Error, changeentityproperty({ent}, 'energycost', {animation}, {cost}, {mponly}, {disable}): {animation} parameter invalid. Make sure the animation exists. \n");
5985 }
5989 }
5993 }
5997 }
6000 }
6002 {
6006 }
6010 }
6014 }
6018 }
6022 }
6026 }
6028 }
6030 {
6034 }
6036 {
6040 }
6042 //printf("Property name '%s' is not supported by function changeentityproperty.\n", propname);
6045 }
6048 changeentityproperty_error:
6051 }
6053 //tossentity(entity, height, speedx, speedz)
6061 }
6071 }
6077 }
6078 }
6083 }
6084 }
6089 }
6090 }
6095 }
6097 // ===== getplayerproperty =====
6099 _gpp_credits,
6100 _gpp_ent,
6101 _gpp_entity,
6102 _gpp_keys,
6103 _gpp_lives,
6104 _gpp_name,
6105 _gpp_playkeys,
6106 _gpp_score,
6107 _gpp_weaponum,
6108 _gpp_the_end,
6109 };
6124 "weaponum"
6125 };
6130 // property name
6133 }
6135 //getplayerproperty(index, propname);
6136 s32 openbor_getplayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6137 s32 ltemp;
6146 }
6157 {
6159 }
6164 printf
6165 ("Function call getplayerproperty has invalid propery name parameter, it must be a string value.\n");
6168 }
6171 //change the model
6175 {
6179 }
6181 {
6185 }
6187 {
6191 }
6193 {
6197 }
6199 {
6203 }
6205 {
6209 }
6211 {
6215 else
6218 }
6220 {
6224 }
6225 //this property is not known
6226 //default:{
6227 // .....
6228 //}
6229 }
6231 }
6233 // ===== changeplayerproperty =====
6235 _cpp_credits,
6236 _cpp_lives,
6237 _cpp_name,
6238 _cpp_playkeys,
6239 _cpp_score,
6240 _cpp_weapon,
6241 _cpp_the_end,
6242 };
6255 };
6260 // property name
6263 }
6265 //changeplayerproperty(index, propname, value[, value2, value3,...]);
6266 s32 openbor_changeplayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6277 }
6289 {
6291 }
6297 }
6302 //change the model
6305 {
6314 }
6320 }
6322 {
6324 //printf();
6326 }
6331 }
6333 {
6343 }
6345 {
6348 else
6351 }
6353 {
6356 else
6359 }
6361 {
6365 else
6370 }
6371 //this property is not known, so return 0
6372 //default:
6373 // (*pretvar)->lVal = (s32)0;
6374 }
6377 }
6379 //checkhole(x,z), return 1 if there's hole here
6387 }
6400 (*pretvar)->lVal = (s32) (checkhole((float) x, (float) z) && checkwall((float) x, (float) z) < 0);
6402 }
6404 //checkwall(x,z), return wall height, or 0
6413 }
6428 }
6430 }
6432 //checkplatformbelow(x,z,a), return the highest platfrom entity below
6433 s32 openbor_checkplatformbelow(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6440 }
6460 }
6462 s32 openbor_openfilestream(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6475 }
6484 }
6492 }
6500 }
6501 // Load file from saves directory if specified
6506 #ifndef DC
6510 }
6511 #endif
6529 }
6537 }
6539 s32 openbor_getfilestreamline(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6543 s32 filestreamindex;
6548 }
6560 while(level->filestreams[filestreamindex].buf[level->filestreams[filestreamindex].pos + length]
6561 && level->filestreams[filestreamindex].buf[level->filestreams[filestreamindex].pos + length] != '\n'
6562 && level->filestreams[filestreamindex].buf[level->filestreams[filestreamindex].pos + length] != '\r')
6567 MAX_STR_VAR_LEN);
6571 length);
6574 }
6576 }
6578 s32 openbor_getfilestreamargument(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6586 }
6598 printf
6599 ("You must give a string value specifying what kind of value you want the argument converted to.\n");
6601 }
6614 (level->filestreams[filestreamindex].buf + level->filestreams[filestreamindex].pos, argument));
6620 (level->filestreams[filestreamindex].buf + level->filestreams[filestreamindex].pos, argument));
6624 }
6627 }
6629 s32 openbor_filestreamnextline(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6631 s32 filestreamindex;
6636 }
6650 }
6652 s32 openbor_getfilestreamposition(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6654 s32 filestreamindex;
6659 }
6668 }
6670 s32 openbor_setfilestreamposition(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6678 }
6690 }
6692 s32 openbor_filestreamappend(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6693 s32 filestreamindex;
6695 s32 appendtype;
6696 s32 ltemp;
6705 }
6728 }
6736 temp = (char *) malloc(sizeof(char) * (strlen(level->filestreams[filestreamindex].buf) + strlen(append) + 4));
6748 }
6753 }
6755 s32 openbor_createfilestream(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6764 }
6769 // Initialize the new filestream
6775 }
6777 s32 openbor_savefilestream(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
6779 s32 filestreamindex;
6790 }
6803 }
6804 // Get the saves directory
6807 // get the packfile's name by chopping off the rest of the path
6813 }
6816 // For packfiles without '/'
6819 y++;
6820 }
6821 // For packfiles with '/'
6824 y++;
6825 }
6826 }
6828 // Make ./Saves/PAKNAME if it doesn't exist
6830 #ifndef DC
6832 #endif
6834 // Add user's filename to path and write the filestream to it
6840 disCcWarns =
6841 fwrite(level->filestreams[filestreamindex].buf, 1, strlen(level->filestreams[filestreamindex].buf), handle);
6843 // add blank line so it can be read successfully
6848 }
6850 //damageentity(entity, other, force, drop, type)
6856 s_attack attack;
6861 }
6879 }
6883 }
6891 }
6896 }
6900 }
6911 }
6916 }
6918 //killentity(entity)
6925 }
6933 }
6937 }
6939 //findtarget(entity, int animation);
6948 }
6956 }
6964 else
6968 }
6970 //checkrange(entity, target, int ani);
6995 printf("Animation id out of range: %d / %d.\n", (int) ani, dyn_anim_custom_maxvalues.max_animations);
6997 }
7003 checkrange_error:
7004 printf
7005 ("Function needs at least 2 valid entity handles, the third parameter is optional: checkrange(entity, target, int animnum)\n");
7008 }
7010 //clearspawnentry();
7011 s32 openbor_clearspawnentry(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
7016 }
7018 // ===== setspawnentry =====
7020 _sse_2phealth,
7021 _sse_2pitem,
7022 _sse_3phealth,
7023 _sse_3pitem,
7024 _sse_4phealth,
7025 _sse_4pitem,
7026 _sse_aggression,
7027 _sse_alias,
7028 _sse_alpha,
7029 _sse_boss,
7030 _sse_coords,
7031 _sse_credit,
7032 _sse_dying,
7033 _sse_flip,
7034 _sse_health,
7035 _sse_item,
7036 _sse_itemalias,
7037 _sse_itemhealth,
7038 _sse_itemmap,
7039 _sse_map,
7040 _sse_mp,
7041 _sse_multiple,
7042 _sse_name,
7043 _sse_nolife,
7044 _sse_weapon,
7045 _sse_the_end,
7046 };
7077 };
7079 MAPSTRINGS(varlist[0], proplist, _sse_the_end, "Property name '%s' is not supported by setspawnentry.\n");
7080 }
7082 //setspawnentry(propname, value1[, value2, value3, ...]);
7083 s32 openbor_setspawnentry(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
7084 s32 ltemp;
7093 }
7104 }
7113 printf
7116 }
7138 else
7157 else
7163 else
7174 else
7180 else
7186 else
7193 else
7198 else
7200 }
7204 else
7206 }
7212 else
7218 else
7224 else
7230 else
7236 else
7243 else
7248 else
7250 }
7254 else
7256 }
7262 else
7268 else
7274 else
7280 else
7286 else
7295 //printf("Property name '%s' is not supported by setspawnentry.\n", propname);
7297 }
7300 setspawnentry_error:
7303 }
7305 //spawn();
7318 }
7320 //entity * projectile(char *name, float x, float z, float a, int direction, int type, int ptype, int map);
7339 }
7344 ent =
7349 ent =
7353 }
7360 projectile_error:
7361 printf
7362 ("Function requires 8 values: entity * projectile(char *name, float x, float z, float a, int direction, int type, int ptype, int map)\n");
7364 }
7366 #define SAMPLE_GO samples.go
7367 #define SAMPLE_BEAT samples.beat
7368 #define SAMPLE_BLOCK samples.block
7369 #define SAMPLE_INDIRECT samples.indirect
7370 #define SAMPLE_GET samples.get
7371 #define SAMPLE_GET2 samples.get2
7372 #define SAMPLE_FALL samples.fall
7373 #define SAMPLE_JUMP samples.jump
7374 #define SAMPLE_PUNCH samples.punch
7375 #define SAMPLE_1UP samples.oneup
7376 #define SAMPLE_TIMEOVER samples.timeover
7377 #define SAMPLE_BEEP samples.beep
7378 #define SAMPLE_BEEP2 samples.beep2
7379 #define SAMPLE_BIKE samples.bike
7382 // ===== openborconstant =====
7384 #define ICMPCONST(x) \
7385 case CMD_SCRIPT_CONSTANT_ ##x: \
7386 value = x; break;
7389 scriptConstantsCommands cmd;
7390 VARTYPE vartype;
7551 //ICMPCONST(ANI_ATTACK1);// move these below because we have some dynamic animation ids
7552 //ICMPCONST(ANI_ATTACK2);
7553 //ICMPCONST(ANI_ATTACK3);
7554 //ICMPCONST(ANI_ATTACK4);
7565 //ICMPCONST(ANI_FREESPECIAL);// move these below because we have some dynamic animation ids
7569 //ICMPCONST(ANI_FREESPECIAL2);
7571 //ICMPCONST(ANI_FREESPECIAL3);
7588 //ICMPCONST(ANI_FREESPECIAL4);
7589 //ICMPCONST(ANI_FREESPECIAL5);
7590 //ICMPCONST(ANI_FREESPECIAL6);
7591 //ICMPCONST(ANI_FREESPECIAL7);
7592 //ICMPCONST(ANI_FREESPECIAL8);
7626 //ICMPCONST(ANI_FOLLOW1); // move these below because we have some dynamic animation ids
7627 //ICMPCONST(ANI_FOLLOW2);
7628 //ICMPCONST(ANI_FOLLOW3);
7629 //ICMPCONST(ANI_FOLLOW4);
7728 }
7731 }
7732 }
7734 #undef ICMPCONST
7737 CMD_SCRIPT_CONSTANT_ANI_DOWN,
7738 CMD_SCRIPT_CONSTANT_ANI_UP,
7739 CMD_SCRIPT_CONSTANT_ANI_BACKWALK,
7740 CMD_SCRIPT_CONSTANT_ANI_WALK,
7741 CMD_SCRIPT_CONSTANT_ANI_IDLE,
7742 CMD_SCRIPT_CONSTANT_ANI_FALL,
7743 CMD_SCRIPT_CONSTANT_ANI_ATTACK,
7744 CMD_SCRIPT_CONSTANT_ANI_FOLLOW,
7745 CMD_SCRIPT_CONSTANT_ANI_RISE,
7746 CMD_SCRIPT_CONSTANT_ANI_RISEATTACK,
7747 CMD_SCRIPT_CONSTANT_ANI_PAIN,
7748 CMD_SCRIPT_CONSTANT_ANI_DIE,
7749 CMD_SCRIPT_CONSTANT_ANI_FREESPECIAL,
7750 };
7766 };
7768 #define ani_num_translations (ARRAY_SIZE(ani_targets))
7770 //openborconstant(constname);
7771 //translate a constant by string, used to retrieve a constant or macro of openbor
7778 scriptConstantsCommands cmd;
7784 }
7790 {
7796 }
7797 // if we get to this point, it's a dynamic animation id
7814 }
7815 }
7816 out_1:
7847 }
7857 }
7860 }
7861 }
7862 }
7866 }
7868 //int rgbcolor(int r, int g, int b);
7885 rgbcolor_error:
7888 }
7890 // ===== playerkeys =====
7892 _pk_anybutton,
7893 _pk_attack,
7894 _pk_attack2,
7895 _pk_attack3,
7896 _pk_attack4,
7897 _pk_esc,
7898 _pk_jump,
7899 _pk_movedown,
7900 _pk_moveleft,
7901 _pk_moveright,
7902 _pk_moveup,
7903 _pk_screenshot,
7904 _pk_special,
7905 _pk_start,
7906 _pk_the_end,
7907 };
7914 {
7929 };
7932 MAPSTRINGS(varlist[i], proplist, _pk_the_end, "Button name '%s' is not supported by playerkeys.");
7933 }
7934 }
7936 //playerkeys(playerindex, newkey?, key1, key2, ...);
7938 s32 ltemp;
7941 u32 keys;
7947 }
7961 else
7968 else
8019 }
8024 }
8027 }
8029 //playmusic(name, loop)
8039 }
8041 //printf("");
8043 }
8048 }
8053 }
8058 }
8060 //fademusic(fade, name, loop, offset)
8080 }
8083 fademusic_error:
8084 printf
8085 ("Function requires 1 value, with an optional 3 for music triggering: fademusic_error(float fade, char name, int loop, unsigned long offset)\n");
8087 }
8089 //setmusicvolume(left, right)
8090 s32 openbor_setmusicvolume(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8095 }
8109 setmusicvolume_error:
8112 }
8114 //setmusicvolume(left, right)
8115 s32 openbor_setmusictempo(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8116 s32 new_tempo;
8120 }
8127 }
8129 //pausemusic(value)
8134 }
8140 }
8142 //playsample(id, priority, lvolume, rvolume, speed, loop)
8154 }
8156 printf("Invalid Id for playsample(id=%d, priority=%d, lvolume=%d, rvolume=%d, speed=%d, loop=%d)\n",
8157 (int) value[0], (unsigned int) value[1], (int) value[2], (int) value[3], (unsigned int) value[4],
8160 }
8164 else
8169 playsample_error:
8171 printf
8172 ("Function requires 6 integer values: playsample(int id, unsigned int priority, int lvolume, int rvolume, unsigned int speed, int loop)\n");
8174 }
8176 // int loadsample(filename, log)
8182 }
8191 }
8192 }
8198 loadsample_error:
8199 printf
8200 ("Function requires 1 string value and optional log value: loadsample(string {filename} integer {log})\n");
8203 }
8205 // void unloadsample(id)
8207 s32 id;
8218 unloadsample_error:
8221 }
8223 //fadeout(type, speed);
8225 s32 type;
8226 s32 speed;
8238 fade_out_error:
8241 }
8243 //changepalette(index);
8244 s32 openbor_changepalette(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8245 s32 index;
8259 changepalette_error:
8262 }
8264 //changelight(x, z);
8279 }
8286 }
8289 changelight_error:
8292 }
8294 //changeshadowcolor(color, alpha);
8295 // color = 0 means no gfxshadow, -1 means don't fill the shadow with colour
8296 // alpha default to 2, <=0 means no alpha effect
8297 s32 openbor_changeshadowcolor(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8314 }
8317 changeshadowcolor_error:
8318 printf
8319 ("Function requires at least 1 integer value, the 2nd integer parameter is optional: changepalette(int colorindex, int alpha)\n");
8321 }
8323 // ===== gettextobjproperty(name, value) =====
8325 _gtop_font,
8326 _gtop_text,
8327 _gtop_time,
8328 _gtop_x,
8329 _gtop_y,
8330 _gtop_z,
8331 _gtop_the_end,
8332 };
8344 };
8351 }
8353 s32 openbor_gettextobjproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8354 s32 ind;
8362 printf("Function's 1st argument must be a numeric value: gettextproperty(int index, \"property\")\n");
8364 }
8372 }
8378 }
8384 {
8388 }
8390 {
8394 }
8396 {
8400 }
8402 {
8406 }
8408 {
8412 }
8414 {
8418 }
8420 //printf("Property name '%s' is not supported by function gettextobjproperty.\n", propname);
8423 }
8427 gettextobjproperty_error:
8430 }
8432 // ===== changetextobjproperty(name, value) =====
8434 _ctop_font,
8435 _ctop_text,
8436 _ctop_time,
8437 _ctop_x,
8438 _ctop_y,
8439 _ctop_z,
8440 _ctop_the_end,
8441 };
8454 };
8460 }
8462 s32 openbor_changetextobjproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8463 s32 ind;
8465 s32 ltemp;
8472 printf
8473 ("Function's 1st argument must be a numeric value: changetextobjproperty(int index, \"property\", value)\n");
8475 }
8483 }
8489 }
8495 {
8499 }
8501 }
8503 {
8507 }
8510 }
8512 MAX_STR_VAR_LEN);
8513 //level->textobjs[ind].text = (char*)StrCache_Get(varlist[2]->strVal);
8516 }
8518 {
8522 }
8524 }
8526 {
8530 }
8532 }
8534 {
8538 }
8540 }
8542 {
8546 }
8548 }
8550 //printf("Property name '%s' is not supported by function changetextobjproperty.\n", propname);
8553 }
8557 changetextobjproperty_error:
8560 }
8562 // changelevelproperty(name, value)
8564 s32 ind;
8565 s32 ltemp;
8571 printf
8572 ("Function's 1st argument must be a numeric value: settextobj(int index, int x, int y, int font, int z, char text, int time {optional})\n");
8574 }
8581 }
8586 }
8591 }
8596 }
8601 }
8606 }
8612 }
8613 }
8617 }
8618 strncpy(level->textobjs[ind].text, (char *) StrCache_Get(varlist[5]->strVal), MAX_STR_VAR_LEN);
8623 settextobj_error:
8626 }
8629 s32 ind;
8638 }
8645 }
8657 cleartextobj_error:
8660 }
8663 // ===== getbglayerproperty ======
8665 _gbglp_alpha,
8666 _gbglp_amplitude,
8667 _gbglp_bgspeedratio,
8668 _gbglp_enabled,
8669 _gbglp_transparency,
8670 _gbglp_watermode,
8671 _gbglp_wavelength,
8672 _gbglp_wavespeed,
8673 _gbglp_xoffset,
8674 _gbglp_xratio,
8675 _gbglp_xrepeat,
8676 _gbglp_xspacing,
8677 _gbglp_zoffset,
8678 _gbglp_zratio,
8679 _gbglp_zrepeat,
8680 _gbglp_zspacing,
8681 _gbglp_the_end,
8682 };
8705 };
8711 }
8713 s32 openbor_getbglayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8714 s32 ind;
8721 printf
8722 ("Function's 1st argument must be a numeric value: getbglayerproperty(int index, \"property\", value)\n");
8724 }
8732 }
8737 }
8743 {
8747 }
8749 {
8753 }
8755 {
8759 }
8761 {
8765 }
8767 {
8771 }
8773 {
8777 }
8780 {
8784 }
8786 {
8790 }
8792 {
8796 }
8798 {
8802 }
8804 {
8808 }
8810 {
8814 }
8816 {
8820 }
8822 {
8826 }
8828 {
8832 }
8834 {
8838 }
8840 //printf("Property name '%s' is not supported by function getbglayerproperty.\n", propname);
8843 }
8847 getbglayerproperty_error:
8850 }
8852 // ===== changebglayerproperty =====
8854 _cbglp_alpha,
8855 _cbglp_amplitude,
8856 _cbglp_bgspeedratio,
8857 _cbglp_enabled,
8858 _cbglp_transparency,
8859 _cbglp_watermode,
8860 _cbglp_wavelength,
8861 _cbglp_wavespeed,
8862 _cbglp_xoffset,
8863 _cbglp_xratio,
8864 _cbglp_xrepeat,
8865 _cbglp_xspacing,
8866 _cbglp_zoffset,
8867 _cbglp_zratio,
8868 _cbglp_zrepeat,
8869 _cbglp_zspacing,
8870 _cbglp_the_end,
8871 };
8894 };
8900 }
8902 s32 openbor_changebglayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
8903 s32 ind;
8905 s32 ltemp;
8913 printf
8914 ("Function's 1st argument must be a numeric value: changebglayerproperty(int index, \"property\", value)\n");
8916 }
8924 }
8929 }
8935 {
8939 }
8941 }
8943 {
8947 }
8949 }
8951 {
8955 }
8957 }
8959 {
8963 }
8965 }
8967 {
8971 }
8973 }
8975 {
8979 }
8981 }
8984 {
8988 }
8990 }
8992 {
8996 }
8998 }
9000 {
9004 }
9006 }
9008 {
9012 }
9014 }
9016 {
9020 }
9022 }
9024 {
9028 }
9030 }
9032 {
9036 }
9038 }
9040 {
9044 }
9046 }
9048 {
9052 }
9054 }
9056 {
9060 }
9062 }
9064 //printf("Property name '%s' is not supported by function changebglayerproperty.\n", propname);
9067 }
9071 changebglayerproperty_error:
9074 }
9076 // ===== getfglayerproperty =====
9078 _gfglp_alpha,
9079 _gfglp_amplitude,
9080 _gfglp_bgspeedratio,
9081 _gfglp_enabled,
9082 _gfglp_transparency,
9083 _gfglp_watermode,
9084 _gfglp_wavelength,
9085 _gfglp_wavespeed,
9086 _gfglp_xoffset,
9087 _gfglp_xratio,
9088 _gfglp_xrepeat,
9089 _gfglp_xspacing,
9090 _gfglp_zoffset,
9091 _gfglp_zratio,
9092 _gfglp_zrepeat,
9093 _gfglp_zspacing,
9094 _gfglp_the_end,
9095 };
9118 };
9124 }
9126 s32 openbor_getfglayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9127 s32 ind;
9135 printf
9136 ("Function's 1st argument must be a numeric value: getfglayerproperty(int index, \"property\", value)\n");
9138 }
9146 }
9151 }
9157 {
9161 }
9163 {
9167 }
9169 {
9173 }
9175 {
9179 }
9181 {
9185 }
9187 {
9191 }
9194 {
9198 }
9200 {
9204 }
9206 {
9210 }
9212 {
9216 }
9218 {
9222 }
9224 {
9228 }
9230 {
9234 }
9236 {
9240 }
9242 {
9246 }
9248 {
9252 }
9254 //printf("Property name '%s' is not supported by function getfglayerproperty.\n", propname);
9257 }
9261 getfglayerproperty_error:
9264 }
9266 // ===== changefglayerproperty =====
9268 _cfglp_alpha,
9269 _cfglp_amplitude,
9270 _cfglp_bgspeedratio,
9271 _cfglp_enabled,
9272 _cfglp_transparency,
9273 _cfglp_watermode,
9274 _cfglp_wavelength,
9275 _cfglp_wavespeed,
9276 _cfglp_xoffset,
9277 _cfglp_xratio,
9278 _cfglp_xrepeat,
9279 _cfglp_xspacing,
9280 _cfglp_zoffset,
9281 _cfglp_zratio,
9282 _cfglp_zrepeat,
9283 _cfglp_zspacing,
9284 _cfglp_the_end,
9308 };
9314 }
9316 s32 openbor_changefglayerproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9317 s32 ind;
9319 s32 ltemp;
9326 printf
9327 ("Function's 1st argument must be a numeric value: changefglayerproperty(int index, \"property\", value)\n");
9329 }
9337 }
9342 }
9348 {
9352 }
9354 }
9356 {
9360 }
9362 }
9364 {
9368 }
9370 }
9372 {
9376 }
9378 }
9380 {
9384 }
9386 }
9388 {
9392 }
9394 }
9397 {
9401 }
9403 }
9405 {
9409 }
9411 }
9413 {
9417 }
9419 }
9421 {
9425 }
9427 }
9429 {
9433 }
9435 }
9437 {
9441 }
9443 }
9445 {
9449 }
9451 }
9453 {
9457 }
9459 }
9461 {
9465 }
9467 }
9469 {
9473 }
9475 }
9477 //printf("Property name '%s' is not supported by function changefglayerproperty.\n", propname);
9480 }
9484 changefglayerproperty_error:
9487 }
9489 s32 openbor_getlevelproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9497 };
9500 _lp_bgspeed,
9501 _lp_cameraxoffset,
9502 _lp_camerazoffset,
9511 }
9520 {
9524 }
9526 {
9530 }
9532 {
9536 }
9541 }
9545 getlevelproperty_error:
9548 }
9550 //changelevelproperty(name, value)
9551 s32 openbor_changelevelproperty(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9553 s32 ltemp;
9559 }
9564 }
9576 else
9581 else
9586 else
9591 else
9593 }
9596 }
9598 //jumptobranch(name, immediate)
9600 s32 ltemp;
9610 strncpy(branch_name, StrCache_Get(varlist[0]->strVal), MIN(MAX_NAME_LEN, MAX_STR_VAR_LEN)); // copy the string value to branch name
9615 // 1 means goto that level immediately, or, wait until the level is complete
9618 }
9621 jumptobranch_error:
9622 printf
9623 ("Function requires 1 string value, the second argument is optional(int): jumptobranch(name, immediate)\n");
9625 }
9627 //bindentity(entity, target, x, z, a, direction, bindanim);
9628 //bindentity(entity, NULL()); // unbind
9639 }
9649 }
9655 // x
9662 }
9665 // z
9671 }
9674 // a
9680 }
9683 // direction
9689 }
9692 // animation
9698 }
9700 BIND:
9704 }
9706 //allocscreen(int w, int h);
9730 }
9734 allocscreen_error:
9738 }
9740 //clearscreen(s_screen* screen)
9756 }
9760 clearscreen_error:
9763 }
9765 //setdrawmethod(entity, int flag, int scalex, int scaley, int flipx, int flipy, int shiftx, int alpha, int remap, int fillcolor, int rotate, int fliprotate, int transparencybg, void* colourmap);
9766 s32 openbor_setdrawmethod(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9780 else
9785 else
9792 }
9815 }
9818 setdrawmethod_error:
9819 printf
9820 ("Function need a valid entity handle and at least 1 interger parameter, all other parameters should be integers: setdrawmethod(entity, int flag, int scalex, int scaley, int flipx, int flipy, int shiftx, int alpha, int remap, int fillcolor, int rotate, int fliprotate, int transparencybg, void* colourmap)\n");
9822 }
9824 //updateframe(entity, int frame);
9826 s32 f;
9838 else
9851 updateframe_error:
9852 printf("Function need a valid entity handle and at an interger parameter: updateframe(entity, int frame)\n");
9854 }
9856 //performattack(entity, int anim, int resetable);
9857 s32 openbor_performattack(ScriptVariant ** varlist, ScriptVariant ** pretvar, int paramCount) {
9869 else
9894 performattack_error:
9895 printf
9896 ("Function need a valid entity handle, the other 2 integer parameters are optional: performattack(entity, int anim, int resetable)\n");
9898 }
9900 //setidle(entity, int anim, int resetable, int stalladd);
9913 else
9944 setidle_error:
9945 printf
9946 ("Function need a valid entity handle, the other 2 integer parameters are optional: setidle(entity, int anim, int resetable, int stalladd)\n");
9948 }
9950 //getentity(int index_from_list)
9952 s32 ind;
9966 }
9967 //else, it should return an empty value
9970 getentity_error:
9974 }
9977 //loadmodel(name)
9991 (void*) load_cached_model(StrCache_Get(varlist[0]->strVal), "openbor_loadmodel", (char) unload);
9992 //else, it should return an empty value
9995 loadmodel_error:
10000 }
10002 // load a sprite which doesn't belong to the sprite_cache
10003 // loadsprite(path)
10013 if(((*pretvar)->ptrVal = (void*) loadsprite2(StrCache_Get(varlist[0]->strVal), NULL, NULL))) {
10015 }
10016 //else, it should return an empty value
10019 loadsprite_error:
10024 }
10026 //playgif(path, int x, int y, int noskip)
10042 }
10044 (s32) playgif(StrCache_Get(varlist[0]->strVal), (int) (temp[0]), (int) (temp[1]), (int) (temp[2]));
10045 palette_set_corrected(pal, savedata.gamma, savedata.gamma, savedata.gamma, savedata.brightness,
10049 playgif_error:
10050 printf
10051 ("Function need a string parameter, other parameters are optional: playgif(path, int x, int y, int noskip)\n");
10054 }