Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include "openmwbindings.hpp"
- namespace MWScriptExtensions
- {
- extern MWScript::InterpreterContext& context;
- extern Interpreter::Interpreter interpreter;//define these in the startexternalscript opcode and install opcodes
- void activate()
- {
- Interpreter::Type_Code codeword = 3388997749;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void additem(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388997750;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void addsoulgem(std::string arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3388998131;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void addspell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997959;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void addtolevcreature(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3388998395;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void addtolevitem(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3388998397;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void addtopic(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997946;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aiactivate(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3254787584;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aiescort(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Integer arg5)
- {
- Interpreter::Type_Code codeword = 3254780416;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 6;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg5!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aiescortcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5, Interpreter::Type_Integer arg6)
- {
- Interpreter::Type_Code codeword = 3254788096;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 7;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg6!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aifollow(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10, Interpreter::Type_Integer arg11, Interpreter::Type_Integer arg12)
- {
- Interpreter::Type_Code codeword = 3254788608;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 13;
- uint optionalArgCount = 8;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg12!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg12);
- argumentsPassed++;
- }
- if (arg11!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg11);
- argumentsPassed++;
- }
- if (arg10!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg10);
- argumentsPassed++;
- }
- if (arg9!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg9);
- argumentsPassed++;
- }
- if (arg8!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg8);
- argumentsPassed++;
- }
- if (arg7!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg7);
- argumentsPassed++;
- }
- if (arg6!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aifollowcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5, Interpreter::Type_Integer arg6)
- {
- Interpreter::Type_Code codeword = 3254789120;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 7;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg6!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aitravel(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
- {
- Interpreter::Type_Code codeword = 3254779904;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 4;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void aiwander(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3, Interpreter::Type_Integer arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10, Interpreter::Type_Integer arg11, Interpreter::Type_Integer arg12)
- {
- Interpreter::Type_Code codeword = 3254784000;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 13;
- uint optionalArgCount = 10;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg12!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg12);
- argumentsPassed++;
- }
- if (arg11!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg11);
- argumentsPassed++;
- }
- if (arg10!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg10);
- argumentsPassed++;
- }
- if (arg9!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg9);
- argumentsPassed++;
- }
- if (arg8!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg8);
- argumentsPassed++;
- }
- if (arg7!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg7);
- argumentsPassed++;
- }
- if (arg6!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void bc(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998215;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void becomewerewolf()
- {
- Interpreter::Type_Code codeword = 3388998167;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void betacomment(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998215;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void cast(std::string arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3388998183;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer cellchanged()
- {
- Interpreter::Type_Code codeword = 3388997632;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void centeroncell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997670;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void centeronexterior(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388998182;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void changeweather(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388997952;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void choice(std::string arg0, Interpreter::Type_Integer arg1, std::string arg2, Interpreter::Type_Integer arg3, std::string arg4, Interpreter::Type_Integer arg5, std::string arg6, Interpreter::Type_Integer arg7, std::string arg8, Interpreter::Type_Integer arg9, std::string arg10, Interpreter::Type_Integer arg11, std::string arg12, Interpreter::Type_Integer arg13, std::string arg14, Interpreter::Type_Integer arg15, std::string arg16, Interpreter::Type_Integer arg17, std::string arg18, Interpreter::Type_Integer arg19, std::string arg20, Interpreter::Type_Integer arg21, std::string arg22, Interpreter::Type_Integer arg23, std::string arg24, Interpreter::Type_Integer arg25, std::string arg26, Interpreter::Type_Integer arg27, std::string arg28, Interpreter::Type_Integer arg29, std::string arg30, Interpreter::Type_Integer arg31)
- {
- Interpreter::Type_Code codeword = 3254782464;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 32;
- uint optionalArgCount = 32;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg31!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg31);
- argumentsPassed++;
- }
- if (arg30!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg30);
- argumentsPassed++;
- }
- if (arg29!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg29);
- argumentsPassed++;
- }
- if (arg28!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg28);
- argumentsPassed++;
- }
- if (arg27!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg27);
- argumentsPassed++;
- }
- if (arg26!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg26);
- argumentsPassed++;
- }
- if (arg25!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg25);
- argumentsPassed++;
- }
- if (arg24!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg24);
- argumentsPassed++;
- }
- if (arg23!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg23);
- argumentsPassed++;
- }
- if (arg22!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg22);
- argumentsPassed++;
- }
- if (arg21!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg21);
- argumentsPassed++;
- }
- if (arg20!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg20);
- argumentsPassed++;
- }
- if (arg19!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg19);
- argumentsPassed++;
- }
- if (arg18!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg18);
- argumentsPassed++;
- }
- if (arg17!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg17);
- argumentsPassed++;
- }
- if (arg16!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg16);
- argumentsPassed++;
- }
- if (arg15!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg15);
- argumentsPassed++;
- }
- if (arg14!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg14);
- argumentsPassed++;
- }
- if (arg13!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg13);
- argumentsPassed++;
- }
- if (arg12!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg12);
- argumentsPassed++;
- }
- if (arg11!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg11);
- argumentsPassed++;
- }
- if (arg10!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg10);
- argumentsPassed++;
- }
- if (arg9!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg9);
- argumentsPassed++;
- }
- if (arg8!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg8);
- argumentsPassed++;
- }
- if (arg7!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg7);
- argumentsPassed++;
- }
- if (arg6!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void clearforcejump()
- {
- Interpreter::Type_Code codeword = 3388998232;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void clearforcemovejump()
- {
- Interpreter::Type_Code codeword = 3388998236;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void clearforcerun()
- {
- Interpreter::Type_Code codeword = 3388997972;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void clearforcesneak()
- {
- Interpreter::Type_Code codeword = 3388997976;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void clearinfoactor()
- {
- Interpreter::Type_Code codeword = 3388998213;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void coc(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997670;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void coe(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388998182;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disablelevitation()
- {
- Interpreter::Type_Code codeword = 3388998176;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayercontrols()
- {
- Interpreter::Type_Code codeword = 3388997765;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayerfighting()
- {
- Interpreter::Type_Code codeword = 3388997766;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayerjumping()
- {
- Interpreter::Type_Code codeword = 3388997767;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayerlooking()
- {
- Interpreter::Type_Code codeword = 3388997768;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayermagic()
- {
- Interpreter::Type_Code codeword = 3388997769;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableplayerviewswitch()
- {
- Interpreter::Type_Code codeword = 3388997770;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disableteleporting()
- {
- Interpreter::Type_Code codeword = 3388998165;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void disablevanitymode()
- {
- Interpreter::Type_Code codeword = 3388997771;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void dontsaveobject()
- {
- Interpreter::Type_Code codeword = 3388997971;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void drop(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388998136;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void dropsoulgem(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998138;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablebirthmenu()
- {
- Interpreter::Type_Code codeword = 3388997646;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableclassmenu()
- {
- Interpreter::Type_Code codeword = 3388997647;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableinventorymenu()
- {
- Interpreter::Type_Code codeword = 3388997651;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablelevelupmenu()
- {
- Interpreter::Type_Code codeword = 3388997655;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablelevitation()
- {
- Interpreter::Type_Code codeword = 3388998177;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablemagicmenu()
- {
- Interpreter::Type_Code codeword = 3388997652;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablemapmenu()
- {
- Interpreter::Type_Code codeword = 3388997653;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablenamemenu()
- {
- Interpreter::Type_Code codeword = 3388997648;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayercontrols()
- {
- Interpreter::Type_Code codeword = 3388997758;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayerfighting()
- {
- Interpreter::Type_Code codeword = 3388997759;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayerjumping()
- {
- Interpreter::Type_Code codeword = 3388997760;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayerlooking()
- {
- Interpreter::Type_Code codeword = 3388997761;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayermagic()
- {
- Interpreter::Type_Code codeword = 3388997762;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableplayerviewswitch()
- {
- Interpreter::Type_Code codeword = 3388997763;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableracemenu()
- {
- Interpreter::Type_Code codeword = 3388997649;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablerest()
- {
- Interpreter::Type_Code codeword = 3388997655;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablestatreviewmenu()
- {
- Interpreter::Type_Code codeword = 3388997650;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablestatsmenu()
- {
- Interpreter::Type_Code codeword = 3388997654;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enableteleporting()
- {
- Interpreter::Type_Code codeword = 3388998166;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void enablevanitymode()
- {
- Interpreter::Type_Code codeword = 3388997764;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void equip(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998067;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void explodespell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998185;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void face(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388998220;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void fadein(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997948;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void fadeout(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997949;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void fadeto(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388997950;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void fall()
- {
- Interpreter::Type_Code codeword = 3388998154;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void fillmap()
- {
- Interpreter::Type_Code codeword = 3388998049;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void forcegreeting()
- {
- Interpreter::Type_Code codeword = 3388997967;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void forcejump()
- {
- Interpreter::Type_Code codeword = 3388998234;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void forcemovejump()
- {
- Interpreter::Type_Code codeword = 3388998238;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void forcerun()
- {
- Interpreter::Type_Code codeword = 3388997974;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void forcesneak()
- {
- Interpreter::Type_Code codeword = 3388997978;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer getacrobatics()
- {
- Interpreter::Type_Code codeword = 3388997794;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getagility()
- {
- Interpreter::Type_Code codeword = 3388997674;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getaipackagedone()
- {
- Interpreter::Type_Code codeword = 3388997756;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getalarm()
- {
- Interpreter::Type_Code codeword = 3388998085;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getalchemy()
- {
- Interpreter::Type_Code codeword = 3388997790;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getalteration()
- {
- Interpreter::Type_Code codeword = 3388997785;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getangle(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997994;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getarmorbonus()
- {
- Interpreter::Type_Code codeword = 3388998260;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getarmorer()
- {
- Interpreter::Type_Code codeword = 3388997775;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getarmortype(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998097;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getathletics()
- {
- Interpreter::Type_Code codeword = 3388997782;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getattackbonus()
- {
- Interpreter::Type_Code codeword = 3388998266;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getattacked()
- {
- Interpreter::Type_Code codeword = 3388998099;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getaxe()
- {
- Interpreter::Type_Code codeword = 3388997780;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getblightdisease()
- {
- Interpreter::Type_Code codeword = 3388998058;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getblindness()
- {
- Interpreter::Type_Code codeword = 3388998263;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getblock()
- {
- Interpreter::Type_Code codeword = 3388997774;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getbluntweapon()
- {
- Interpreter::Type_Code codeword = 3388997778;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getbuttonpressed()
- {
- Interpreter::Type_Code codeword = 3388997943;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getcastpenalty()
- {
- Interpreter::Type_Code codeword = 3388998261;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getchameleon()
- {
- Interpreter::Type_Code codeword = 3388998255;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getcollidingactor()
- {
- Interpreter::Type_Code codeword = 3388998226;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getcollidingpc()
- {
- Interpreter::Type_Code codeword = 3388998224;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getcommondisease()
- {
- Interpreter::Type_Code codeword = 3388998056;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getconjuration()
- {
- Interpreter::Type_Code codeword = 3388997787;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getcurrentaipackage()
- {
- Interpreter::Type_Code codeword = 3388998127;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getcurrenttime()
- {
- Interpreter::Type_Code codeword = 3388998109;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getcurrentweather()
- {
- Interpreter::Type_Code codeword = 3388997951;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getdeadcount(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998051;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getdefendbonus()
- {
- Interpreter::Type_Code codeword = 3388998267;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getdestruction()
- {
- Interpreter::Type_Code codeword = 3388997784;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getdetected(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998129;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getdisposition()
- {
- Interpreter::Type_Code codeword = 3388998054;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer geteffect(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998095;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getenchant()
- {
- Interpreter::Type_Code codeword = 3388997783;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getendurance()
- {
- Interpreter::Type_Code codeword = 3388997676;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getfactionreaction(std::string arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3388998211;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getfatigue()
- {
- Interpreter::Type_Code codeword = 3388997721;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Float getfatiguegetratio()
- {
- Interpreter::Type_Code codeword = 3388997745;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getfight()
- {
- Interpreter::Type_Code codeword = 3388998081;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getflee()
- {
- Interpreter::Type_Code codeword = 3388998083;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getflying()
- {
- Interpreter::Type_Code codeword = 3388998259;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getforcejump()
- {
- Interpreter::Type_Code codeword = 3388998240;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getforcemovejump()
- {
- Interpreter::Type_Code codeword = 3388998242;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getforcerun()
- {
- Interpreter::Type_Code codeword = 3388998091;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getforcesneak()
- {
- Interpreter::Type_Code codeword = 3388998092;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer gethandtohand()
- {
- Interpreter::Type_Code codeword = 3388997800;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float gethealth()
- {
- Interpreter::Type_Code codeword = 3388997719;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Float gethealthgetratio()
- {
- Interpreter::Type_Code codeword = 3388997743;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getheavyarmor()
- {
- Interpreter::Type_Code codeword = 3388997777;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer gethello()
- {
- Interpreter::Type_Code codeword = 3388998079;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getillusion()
- {
- Interpreter::Type_Code codeword = 3388997786;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getintelligence()
- {
- Interpreter::Type_Code codeword = 3388997672;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getinterior()
- {
- Interpreter::Type_Code codeword = 3388997937;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getinvisible()
- {
- Interpreter::Type_Code codeword = 3388998265;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getitemcount(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997752;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getjournalindex(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997941;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlevel()
- {
- Interpreter::Type_Code codeword = 3388998028;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlightarmor()
- {
- Interpreter::Type_Code codeword = 3388997795;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlineofsight(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998178;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlocked()
- {
- Interpreter::Type_Code codeword = 3388998087;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlongblade()
- {
- Interpreter::Type_Code codeword = 3388997779;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getlos(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998178;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getluck()
- {
- Interpreter::Type_Code codeword = 3388997678;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getmagicka()
- {
- Interpreter::Type_Code codeword = 3388997720;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Float getmagickagetratio()
- {
- Interpreter::Type_Code codeword = 3388997744;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getmarksman()
- {
- Interpreter::Type_Code codeword = 3388997797;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getmasserphase()
- {
- Interpreter::Type_Code codeword = 3388997668;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getmediumarmor()
- {
- Interpreter::Type_Code codeword = 3388997776;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getmercantile()
- {
- Interpreter::Type_Code codeword = 3388997798;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getmysticism()
- {
- Interpreter::Type_Code codeword = 3388997788;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getparalysis()
- {
- Interpreter::Type_Code codeword = 3388998264;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpccell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997942;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getpccrimelevel()
- {
- Interpreter::Type_Code codeword = 3388998124;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getpcfacrep(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254784512;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcinjail()
- {
- Interpreter::Type_Code codeword = 3388998206;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcjumping()
- {
- Interpreter::Type_Code codeword = 3388998195;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcrank(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254783488;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcrunning()
- {
- Interpreter::Type_Code codeword = 3388998089;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcsleep()
- {
- Interpreter::Type_Code codeword = 3388998047;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpcsneaking()
- {
- Interpreter::Type_Code codeword = 3388998090;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpctraveling()
- {
- Interpreter::Type_Code codeword = 3388998207;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getpersonality()
- {
- Interpreter::Type_Code codeword = 3388997677;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayercontrolsdisabled()
- {
- Interpreter::Type_Code codeword = 3388998005;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayerfightingdisabled()
- {
- Interpreter::Type_Code codeword = 3388998006;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayerjumpingdisabled()
- {
- Interpreter::Type_Code codeword = 3388998007;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayerlookingdisabled()
- {
- Interpreter::Type_Code codeword = 3388998008;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayermagicdisabled()
- {
- Interpreter::Type_Code codeword = 3388998009;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getplayerviewswitchdisabled()
- {
- Interpreter::Type_Code codeword = 3388998010;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getpos(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998032;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getrace(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998105;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getreputation()
- {
- Interpreter::Type_Code codeword = 3388998065;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistblight()
- {
- Interpreter::Type_Code codeword = 3388998249;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistcorprus()
- {
- Interpreter::Type_Code codeword = 3388998250;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistdisease()
- {
- Interpreter::Type_Code codeword = 3388998248;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistfire()
- {
- Interpreter::Type_Code codeword = 3388998245;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistfrost()
- {
- Interpreter::Type_Code codeword = 3388998246;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistmagicka()
- {
- Interpreter::Type_Code codeword = 3388998244;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistnormalweapons()
- {
- Interpreter::Type_Code codeword = 3388998253;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistparalysis()
- {
- Interpreter::Type_Code codeword = 3388998252;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistpoison()
- {
- Interpreter::Type_Code codeword = 3388998251;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getresistshock()
- {
- Interpreter::Type_Code codeword = 3388998247;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getrestoration()
- {
- Interpreter::Type_Code codeword = 3388997789;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getscale()
- {
- Interpreter::Type_Code codeword = 3388997992;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getsecundaphase()
- {
- Interpreter::Type_Code codeword = 3388997669;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getsecurity()
- {
- Interpreter::Type_Code codeword = 3388997792;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getshortblade()
- {
- Interpreter::Type_Code codeword = 3388997796;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getsilence()
- {
- Interpreter::Type_Code codeword = 3388998262;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getsneak()
- {
- Interpreter::Type_Code codeword = 3388997793;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getsoundplaying(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997643;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspear()
- {
- Interpreter::Type_Code codeword = 3388997781;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspeechcraft()
- {
- Interpreter::Type_Code codeword = 3388997799;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspeed()
- {
- Interpreter::Type_Code codeword = 3388997675;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997963;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspelleffects(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998107;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getspellreadied()
- {
- Interpreter::Type_Code codeword = 3388998193;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getsquareroot(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998119;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getstandingactor()
- {
- Interpreter::Type_Code codeword = 3388998158;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getstandingpc()
- {
- Interpreter::Type_Code codeword = 3388998156;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getstartingangle(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998160;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Float getstartingpos(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998036;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getstat(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998222;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getstrength()
- {
- Interpreter::Type_Code codeword = 3388997671;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getsuperjump()
- {
- Interpreter::Type_Code codeword = 3388998258;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getswimspeed()
- {
- Interpreter::Type_Code codeword = 3388998257;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer gettarget(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998200;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getunarmored()
- {
- Interpreter::Type_Code codeword = 3388997791;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getvanitymodedisabled()
- {
- Interpreter::Type_Code codeword = 3388998011;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getwaterbreathing()
- {
- Interpreter::Type_Code codeword = 3388998254;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getwaterlevel()
- {
- Interpreter::Type_Code codeword = 3388997953;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- Interpreter::Type_Integer getwaterwalking()
- {
- Interpreter::Type_Code codeword = 3388998256;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getweapondrawn()
- {
- Interpreter::Type_Code codeword = 3388998103;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getweapontype()
- {
- Interpreter::Type_Code codeword = 3388998112;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getwerewolfkills()
- {
- Interpreter::Type_Code codeword = 3388998114;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer getwillpower()
- {
- Interpreter::Type_Code codeword = 3388997673;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Float getwindspeed()
- {
- Interpreter::Type_Code codeword = 3388998162;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mFloat;
- }
- void goodbye()
- {
- Interpreter::Type_Code codeword = 3388997970;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void gotojail()
- {
- Interpreter::Type_Code codeword = 3388998197;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer hasitemequipped(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998101;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer hassoulgem(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998110;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer hitattemptonme(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998393;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer hitonme(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998163;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void hurtcollidingactor(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998230;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void hurtstandingactor(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998228;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer iswerewolf()
- {
- Interpreter::Type_Code codeword = 3388998141;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void journal(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388997939;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void lock(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3254780928;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void loopgroup(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3254781952;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void lowerrank()
- {
- Interpreter::Type_Code codeword = 3388998122;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void menutest(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3254791168;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modacrobatics(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997902;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modagility(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997706;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modalarm(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998077;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modalchemy(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997898;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modalteration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997893;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modarmorbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998356;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modarmorer(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997883;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modathletics(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997890;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modattackbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998362;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modaxe(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997888;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modblindness(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998359;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modblock(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997882;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modbluntweapon(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997886;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modcastpenalty(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998357;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modchameleon(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998351;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modconjuration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997895;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modcurrentfatigue(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997739;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modcurrenthealth(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997737;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modcurrentmagicka(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997738;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void moddefendbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998363;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void moddestruction(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997892;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void moddisposition(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997965;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modenchant(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997891;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modendurance(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997708;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modfactionreaction(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3388998210;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modfatigue(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997733;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modfight(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998073;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modflee(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998075;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modflying(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998355;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modhandtohand(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997908;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modhealth(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997731;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modheavyarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997885;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modhello(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998071;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modillusion(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997894;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modintelligence(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997704;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modinvisible(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998361;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modlightarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997903;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modlongblade(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997887;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modluck(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997710;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modmagicka(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997732;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modmarksman(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997905;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modmediumarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997884;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modmercantile(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997906;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modmysticism(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997896;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modparalysis(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998360;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modpccrimelevel(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998126;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modpcfacrep(Interpreter::Type_Integer arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3254785536;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modpersonality(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997709;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modregion(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Integer arg2, Interpreter::Type_Integer arg3, Interpreter::Type_Integer arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10)
- {
- Interpreter::Type_Code codeword = 3254789632;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 11;
- uint optionalArgCount = 10;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg10!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg10);
- argumentsPassed++;
- }
- if (arg9!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg9);
- argumentsPassed++;
- }
- if (arg8!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg8);
- argumentsPassed++;
- }
- if (arg7!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg7);
- argumentsPassed++;
- }
- if (arg6!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg6);
- argumentsPassed++;
- }
- if (arg5!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modreputation(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998062;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistblight(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998345;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistcorprus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998346;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistdisease(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998344;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistfire(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998341;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistfrost(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998342;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistmagicka(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998340;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistnormalweapons(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998349;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistparalysis(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998348;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistpoison(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998347;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modresistshock(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998343;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modrestoration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997897;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modscale(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998115;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modsecurity(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997900;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modshortblade(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997904;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modsilence(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998358;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modsneak(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997901;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modspear(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997889;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modspeechcraft(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997907;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modspeed(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997707;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modstrength(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997703;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modsuperjump(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998354;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modswimspeed(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998353;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modunarmored(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997899;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modwaterbreathing(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998350;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modwaterlevel(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997955;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modwaterwalking(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998352;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void modwillpower(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997705;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void move(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388998150;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void moveworld(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388998152;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer onactivate()
- {
- Interpreter::Type_Code codeword = 3388997645;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer ondeath()
- {
- Interpreter::Type_Code codeword = 3388998140;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer onknockout()
- {
- Interpreter::Type_Code codeword = 3388998208;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- Interpreter::Type_Integer onmurder()
- {
- Interpreter::Type_Code codeword = 3388998217;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void payfine()
- {
- Interpreter::Type_Code codeword = 3388998198;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void payfinethief()
- {
- Interpreter::Type_Code codeword = 3388998199;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void pcclearexpelled(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254787072;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void pcexpell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254786560;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer pcexpelled(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254786048;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void pcforce1stperson()
- {
- Interpreter::Type_Code codeword = 3388998390;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void pcforce3rdperson()
- {
- Interpreter::Type_Code codeword = 3388998391;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer pcget3rdperson()
- {
- Interpreter::Type_Code codeword = 3388998392;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void pcjoinfaction(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254783232;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void pclowerrank(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254782976;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void pcraiserank(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3254782720;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void placeatme(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
- {
- Interpreter::Type_Code codeword = 3388998045;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 4;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void placeatpc(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
- {
- Interpreter::Type_Code codeword = 3388998044;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 4;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg3!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void placeitem(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4)
- {
- Interpreter::Type_Code codeword = 3388998043;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 5;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void placeitemcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5)
- {
- Interpreter::Type_Code codeword = 3388998042;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 6;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg5!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg5);
- argumentsPassed++;
- }
- if (arg4!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg4);
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playbink(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388998135;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playgroup(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3254781440;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playloopsound3d(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997640;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playloopsound3dvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
- {
- Interpreter::Type_Code codeword = 3388997641;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playsound(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997636;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playsound3d(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997638;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playsound3dvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
- {
- Interpreter::Type_Code codeword = 3388997639;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void playsoundvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
- {
- Interpreter::Type_Code codeword = 3388997637;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void position(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3)
- {
- Interpreter::Type_Code codeword = 3388998038;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 4;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void positioncell(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, std::string arg4)
- {
- Interpreter::Type_Code codeword = 3388998040;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 5;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg4!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg4));
- argumentsPassed++;
- }
- if (arg3!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg3);
- argumentsPassed++;
- }
- if (arg2!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void ra()
- {
- Interpreter::Type_Code codeword = 3388998388;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void raiserank()
- {
- Interpreter::Type_Code codeword = 3388998120;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removeeffects(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998189;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removefromlevcreature(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3388998396;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removefromlevitem(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
- {
- Interpreter::Type_Code codeword = 3388998398;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 3;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg2!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg2);
- argumentsPassed++;
- }
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removeitem(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388997754;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removesoulgem(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3254789888;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removespell(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997961;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void removespelleffects(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998187;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void resetactors()
- {
- Interpreter::Type_Code codeword = 3388998388;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void resurrect()
- {
- Interpreter::Type_Code codeword = 3388998191;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void rotate(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388998143;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void rotateworld(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388998145;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer samefaction()
- {
- Interpreter::Type_Code codeword = 3388998069;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void say(std::string arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3388997633;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer saydone()
- {
- Interpreter::Type_Code codeword = 3388997634;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- void setacrobatics(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997848;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setagility(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997690;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setalarm(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997986;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setalchemy(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997844;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setalteration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997839;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setangle(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388997990;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setarmorbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998308;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setarmorer(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997829;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setathletics(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997836;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setatstart()
- {
- Interpreter::Type_Code codeword = 3388998147;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setattackbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998314;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setaxe(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997834;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setblindness(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998311;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setblock(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997828;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setbluntweapon(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997832;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setcastpenalty(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998309;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setchameleon(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998303;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setconjuration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997841;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setdefendbonus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998315;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setdelete(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998117;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setdestruction(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997838;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setdisposition(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998052;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setenchant(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997837;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setendurance(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997692;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setfatigue(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997727;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setfight(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997982;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setflee(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997984;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setflying(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998307;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void sethandtohand(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997854;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void sethealth(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997725;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setheavyarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997831;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void sethello(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997980;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setillusion(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997840;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setintelligence(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997688;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setinvisible(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998313;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setjournalindex(std::string arg0, Interpreter::Type_Integer arg1)
- {
- Interpreter::Type_Code codeword = 3388997940;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setlevel(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998030;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setlightarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997849;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setlongblade(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997833;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setluck(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997694;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setmagicka(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997726;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setmarksman(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997851;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setmediumarmor(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997830;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setmercantile(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997852;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setmysticism(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997842;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setparalysis(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998312;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setpccrimelevel(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388998125;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setpcfacrep(Interpreter::Type_Integer arg0, std::string arg1)
- {
- Interpreter::Type_Code codeword = 3254785024;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 1;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
- argumentsPassed++;
- }
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setpersonality(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997693;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setpos(std::string arg0, Interpreter::Type_Float arg1)
- {
- Interpreter::Type_Code codeword = 3388998034;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 2;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg1!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg1);
- argumentsPassed++;
- }
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setreputation(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998061;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistblight(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998297;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistcorprus(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998298;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistdisease(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998296;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistfire(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998293;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistfrost(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998294;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistmagicka(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998292;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistnormalweapons(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998301;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistparalysis(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998300;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistpoison(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998299;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setresistshock(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998295;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setrestoration(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997843;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setscale(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997988;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setsecurity(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997846;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setshortblade(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997850;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setsilence(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998310;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setsneak(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997847;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setspear(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997835;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setspeechcraft(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997853;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setspeed(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997691;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setstrength(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997687;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setsuperjump(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998306;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setswimspeed(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998305;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setunarmored(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997845;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setwaterbreathing(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998302;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setwaterlevel(Interpreter::Type_Float arg0)
- {
- Interpreter::Type_Code codeword = 3388997954;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushFloat(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setwaterwalking(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388998304;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setwerewolfacrobatics()
- {
- Interpreter::Type_Code codeword = 3388998171;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void setwillpower(Interpreter::Type_Integer arg0)
- {
- Interpreter::Type_Code codeword = 3388997689;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!=-123456)
- {
- Compiler::Generator.pushInt(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void showmap(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998048;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void showrestmenu()
- {
- Interpreter::Type_Code codeword = 3388997656;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void showvars()
- {
- Interpreter::Type_Code codeword = 3388998173;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void skipanim()
- {
- Interpreter::Type_Code codeword = 3388997944;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void startcombat(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388998202;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void stopcombat()
- {
- Interpreter::Type_Code codeword = 3388998204;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void stopsound(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997642;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void streammusic(std::string arg0)
- {
- Interpreter::Type_Code codeword = 3388997635;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 1;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- if (arg0!="OPTIONAL_FLAG")
- {
- Compiler::Generator.pushString(code, literals, arg0);
- argumentsPassed++;
- }
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void sv()
- {
- Interpreter::Type_Code codeword = 3388998173;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tai()
- {
- Interpreter::Type_Code codeword = 3388998180;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tcb()
- {
- Interpreter::Type_Code codeword = 3388998060;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tcg()
- {
- Interpreter::Type_Code codeword = 3388997938;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tcl()
- {
- Interpreter::Type_Code codeword = 3388997936;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tfh()
- {
- Interpreter::Type_Code codeword = 3388997969;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tfow()
- {
- Interpreter::Type_Code codeword = 3388997957;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tgm()
- {
- Interpreter::Type_Code codeword = 3388998175;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tm()
- {
- Interpreter::Type_Code codeword = 3388998219;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void toggleai()
- {
- Interpreter::Type_Code codeword = 3388998180;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglecollision()
- {
- Interpreter::Type_Code codeword = 3388997936;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglecollisionboxes()
- {
- Interpreter::Type_Code codeword = 3388998060;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglecollisiongrid()
- {
- Interpreter::Type_Code codeword = 3388997938;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglefogofwar()
- {
- Interpreter::Type_Code codeword = 3388997957;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglefullhelp()
- {
- Interpreter::Type_Code codeword = 3388997969;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglegodmode()
- {
- Interpreter::Type_Code codeword = 3388998175;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglemenus()
- {
- Interpreter::Type_Code codeword = 3388998219;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglepathgrid()
- {
- Interpreter::Type_Code codeword = 3388997958;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglesky()
- {
- Interpreter::Type_Code codeword = 3388997665;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglevanitymode()
- {
- Interpreter::Type_Code codeword = 3388998004;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglewater()
- {
- Interpreter::Type_Code codeword = 3388997956;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void togglewireframe()
- {
- Interpreter::Type_Code codeword = 3388997947;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void toggleworld()
- {
- Interpreter::Type_Code codeword = 3388998389;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tpg()
- {
- Interpreter::Type_Code codeword = 3388997958;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void ts()
- {
- Interpreter::Type_Code codeword = 3388997665;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void turnmoonred()
- {
- Interpreter::Type_Code codeword = 3388997667;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void turnmoonwhite()
- {
- Interpreter::Type_Code codeword = 3388997666;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tvm()
- {
- Interpreter::Type_Code codeword = 3388998004;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void tw()
- {
- Interpreter::Type_Code codeword = 3388998389;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void twa()
- {
- Interpreter::Type_Code codeword = 3388997956;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void twf()
- {
- Interpreter::Type_Code codeword = 3388997947;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void undowerewolf()
- {
- Interpreter::Type_Code codeword = 3388998169;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void unlock()
- {
- Interpreter::Type_Code codeword = 3388997772;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- void wakeuppc()
- {
- Interpreter::Type_Code codeword = 3388998050;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return;
- }
- Interpreter::Type_Integer xbox()
- {
- Interpreter::Type_Code codeword = 3388997644;//codeword without arguments
- Literals& literals;
- std::vector<Interpreter::Type_Code> code;
- uint argCount = 0;
- uint optionalArgCount = 0;
- uint argumentsPassed = 0;
- uint optionalArgumentsPassed = 0;
- optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
- // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
- if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
- //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
- interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
- return runtime[0].mInteger;
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement