void Operation::variable_set(ScenarioRunner* sr)
{
Parameter id = sr->getParameter();
uint32_t value = sr->getDWORD();
sr->setLogicVar(static_cast<uint8_t>(id.type),id.value.dword,value);
std::cout << "VAR(" << hexString(static_cast<uint8_t>(id.type)) << ";" << hexString(id.value.dword) << ") = " << hexString(sr->getLogicVar(static_cast<uint8_t>(id.type),id.value.dword)) << std::endl;
}
//Variable
void Operation::string_variable_set(ScenarioRunner* sr)
{
uint32_t id = sr->getDWORD();
Parameter value = sr->getParameter();
sr->setStringVar(id, (value.type == p_type::STRING ? value.value.string : sr->getStringVar(value.value.dword)));
LOG("STR_VAR(" + hexString(id) + ") = " + (value.type == p_type::STRING ? value.value.string : "VAR("+hexString(value.value.dword)+") = "+sr->getStringVar(value.value.dword)));
}
void CtrlrMidiBufferStatus::update(const int x, const int y)
{
size.setText(STR(owner.getDataSize()/3));
status.setFont (statusFont);
status.setText ("Byte: ");
CodeDocument::Position pos = owner.getCodeEditor().getPositionAt (x,y);
status.append (STR(pos.getPosition()/3), statusFont.boldened());
status.append ("/"+STR(pos.getPosition()), statusFont);
status.append (" "+currentByte(pos), statusFont);
Range<int> sel = owner.getCodeEditor().getHighlightedRegion();
if (!sel.isEmpty())
{
const int end = sel.getEnd() / 3;
const int start = sel.getStart() / 3;
String selection = owner.getCodeEditor().getTextInRange (Range<int> (sel.getStart(),sel.getEnd())).trim();
status.append (" Selected("+STR((end - start)+1)+"): ", statusFont);
status.append (STR(start), statusFont.boldened());
status.append (" - ", statusFont);
status.append (STR(end), statusFont.boldened());
status.append (" "+hexString(selection), statusFont);
}
repaint();
}
const String CtrlrMidiBufferStatus::currentByte(const CodeDocument::Position &pos)
{
const String current = owner.getCodeEditor().getTextInRange(Range<int>(pos.getPosition(), pos.getPosition()+1));
const String next = owner.getCodeEditor().getTextInRange(Range<int>(pos.getPosition()+1, pos.getPosition()+2));
const String previous = owner.getCodeEditor().getTextInRange(Range<int>(pos.getPosition()-1, pos.getPosition()));
String byte;
String ret;
if (next.trim().isEmpty())
{
byte << previous << current;
}
if (previous.trim().isEmpty())
{
byte << current << next;
}
if (!byte.isEmpty())
{
return (hexString(byte));
}
return (String::empty);
}
bool ledPresets::saveXML() {
printf("SAVING XML: %s", xmlName.c_str() );
// XML.addTag("PRESETS");
// XML.pushTag("PRESETS");
unsigned int ct = 0;
ofxXmlSettings TMP;
for (int i=0; i<presetsNum; i++){
// XML.addTag("PRESET");
// XML.pushTag("PRESET", i);
// XML.addTag("GENERATORS");
// XML.pushTag("GENERATORS");
for (int j=0; j<4; j++){
int lastTagNumber = TMP.addTag("GENERATOR");
// XML.pushTag("GENERATOR", lastTagNumber);
if (presets[i].is_active) {
TMP.setValue("GENERATOR:att", presets[i].generators[j].att, lastTagNumber);
TMP.setValue("GENERATOR:dec", presets[i].generators[j].dec, lastTagNumber);
TMP.setValue("GENERATOR:rel", presets[i].generators[j].rel, lastTagNumber);
TMP.setValue("GENERATOR:quant", (int)presets[i].generators[j].quant, lastTagNumber);
TMP.setValue("GENERATOR:isActive", 1, lastTagNumber);
string strmat((char *) presets[i].generators[j].matrix, ledsW*ledsH*3);
printf("strmat = %s\n", strmat.c_str());
TMP.setValue("GENERATOR:bitmap", strmat, lastTagNumber);
// TMP.setValue(
string strseq = hexString(presets[i].generators[j].sequence, 16*3);
printf("\nSEQ = ");
for (int z=0; z<16*3; z++) printf("%02X", presets[i].generators[j].sequence[i]);
printf("\nstrseq = %s\n", strseq.c_str());
TMP.setValue("GENERATOR:seq", strseq, lastTagNumber);
} else {
TMP.setValue("GENERATOR:att", 0, lastTagNumber);
TMP.setValue("GENERATOR:dec", 0, lastTagNumber);
TMP.setValue("GENERATOR:rel", 0, lastTagNumber);
TMP.setValue("GENERATOR:quant", 0, lastTagNumber);
}
printf("GEN %d\n", lastTagNumber);
ct++;
TMP.popTag();
}
// XML.popTag();
// XML.popTag();
// XML.popTag();
}
// XML.popTag();
TMP.saveFile(xmlName);
return true;
}
void ZLStatisticsXMLReader::startElementHandler(const char *tag, const char **attributes) {
if (STATISTICS_TAG == tag) {
size_t volume = atoi(attributeValue(attributes, "volume"));
unsigned long long squaresVolume = atoll(attributeValue(attributes, "squaresVolume"));
//std::cerr << "XMLReader: frequencies sum & ^2: " << volume << ":" << squaresVolume << "\n";
myStatisticsPtr = new ZLArrayBasedStatistics( atoi(attributeValue(attributes, "charSequenceSize")), atoi(attributeValue(attributes, "size")), volume, squaresVolume);
} else if (ITEM_TAG == tag) {
const char *sequence = attributeValue(attributes, "sequence");
const char *frequency = attributeValue(attributes, "frequency");
if ((sequence != 0) && (frequency != 0)) {
std::string hexString(sequence);
myStatisticsPtr->insert(ZLCharSequence(hexString), atoi(frequency));
}
}
}
void Operation::jump_conditinal(ScenarioRunner* sr)
{
bool verbose = !!sr->getResourceManager()->getConfigVar("DEBUGGER.VERBOSE_CONDITINAL_JUMP", 0);
Parameter a = sr->getParameter();
uint32_t opr = sr->getDWORD(), b = sr->getDWORD();bool cond=false;
if (verbose) std::cout << sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) << "(VAR " << hexString(static_cast<uint8_t>(a.type)) << ";" << hexString(a.value.dword) << ") ";
switch (opr)
{
case 0x0: //!=
if (verbose) std::cout << "!=";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) != b);
break;
case 0x1: //<=
if (verbose) std::cout << "<=";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) <= b);
break;
case 0x2: //>=
if (verbose) std::cout << ">=";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) >= b);
break;
case 0x3: //<
if (verbose) std::cout << "<";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) < b);
break;
case 0x4: //>
std::cout << ">";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type),a.value.dword) > b);
break;
case 0x5: //=
if (verbose) std::cout << "=";
cond = (sr->getLogicVar(static_cast<uint8_t>(a.type), a.value.dword) == b);
break;
default:
if (!sr->exitRequested())
{
ERROR("Unknown Jump Code: "+std::to_string(opr));
}
else { return; }
};
if (verbose) std::cout << " " << hexString(b) << std::endl;
if (cond || sr->getResourceManager()->getConfigVar("ASSERT.JUMP_"+sr->getCurrentScenario()->name+"_"+hexString(static_cast<uint8_t>(a.type))+"."+hexString(a.value.dword)+"_"+hexString(opr)+"_"+hexString(b),0)) {Operation::jump(sr); } else { sr->getDWORD(); };
if (verbose) std::cout << (cond || sr->getResourceManager()->getConfigVar("ASSERT.JUMP_" + sr->getCurrentScenario()->name + "_" + hexString(static_cast<uint8_t>(a.type)) + "." + hexString(a.value.dword) + "_" + hexString(opr) + "_" + hexString(b), 0) ? "Jumped" : "Didn't jump") << std::endl;
}
Parameter ScenarioRunner::getParameter()
{
Parameter p;
if (terminated) return p; //Don't get parameter if termination was requested
p.type = *reinterpret_cast<p_type*>(&buffer[pc++]);
switch (p.type)
{
case p_type::STRING:
{
uint16_t str_size = *reinterpret_cast<uint16_t*>(&buffer[pc]);
for (uint16_t i = 0;i < str_size;i++)
{
if (buffer[pc+2+i] == '\0')
{p.value.string.resize(i);break;}
else
{p.value.string += buffer[pc+2+i];}
}
pc+=2+str_size;
p.value.string = toUTF8(p.value.string);
std::cout << "\"" << p.value.string << "\"" << "; ";
}
break;
case p_type::DWORD_0:
case p_type::DWORD_3:
case p_type::DWORD_5:
case p_type::DWORD_6:
p.value.dword = *reinterpret_cast<uint32_t*>(&buffer[pc]);
std::cout << p.value.dword << "; ";
pc+=4;
break;
case p_type::ADDR:
p.value.dword = *reinterpret_cast<uint32_t*>(&buffer[pc]);
std::cout << "(ADDR)" << hexString(p.value.dword) << "; ";
pc+=4;
break;
default:
ERROR("Unknown Parametercode; This indicates a parsing error");
break;
}
if (debuggingEnabled()) debugger->onParameter(p);
return p;
}
void IntlTestCollator::backAndForth(CollationElementIterator &iter)
{
// Run through the iterator forwards and stick it into an array
int32_t orderLength = 0;
LocalArray<Order> orders(getOrders(iter, orderLength));
UErrorCode status = U_ZERO_ERROR;
// Now go through it backwards and make sure we get the same values
int32_t index = orderLength;
int32_t o;
// reset the iterator
iter.reset();
while ((o = iter.previous(status)) != CollationElementIterator::NULLORDER)
{
/*int32_t offset = */iter.getOffset();
if (index == 0) {
if(o == 0) {
continue;
} else { // this is an error, orders exhausted but there are non-ignorable CEs from
// going backwards
errln("Backward iteration returned a non ignorable after orders are exhausted");
break;
}
}
index -= 1;
if (o != orders[index].order) {
if (o == 0)
index += 1;
else {
while (index > 0 && orders[--index].order == 0) {
// nothing...
}
if (o != orders[index].order) {
errln("Mismatched order at index %d: 0x%0:8X vs. 0x%0:8X", index,
orders[index].order, o);
//break;
return;
}
}
}
#if TEST_OFFSETS
if (offset != orders[index].offset) {
errln("Mismatched offset at index %d: %d vs. %d", index,
orders[index].offset, offset);
//break;
return;
}
#endif
}
while (index != 0 && orders[index - 1].order == 0)
{
index --;
}
if (index != 0)
{
UnicodeString msg("Didn't get back to beginning - index is ");
errln(msg + index);
iter.reset();
err("next: ");
while ((o = iter.next(status)) != CollationElementIterator::NULLORDER)
{
UnicodeString hexString("0x");
appendHex(o, 8, hexString);
hexString += " ";
err(hexString);
}
errln("");
err("prev: ");
while ((o = iter.previous(status)) != CollationElementIterator::NULLORDER)
{
UnicodeString hexString("0x");
appendHex(o, 8, hexString);
hexString += " ";
err(hexString);
}
errln("");
}
}
void hexString::operator -= (const char Right[]){
intValue -= hexString(Right).toInt();
setHexValue();
}
bool operator >= ( hexString Left, std::string Right){return (Left.toInt() >= hexString(Right).toInt());}
uint32_t ScenarioRunner::getLogicVar(uint8_t scope,uint32_t key)
{
if (exitRequested()) return 0;
if (scope != 0x03 && scope != 0x06) ERROR("Invalid scope "+std::to_string(scope));
return reg_logic[hexString(scope)+":"+hexString(key)];
}
ScenarioRunner::ScenarioRunner(std::string path, bool force_debug) : file(path)
{
uint32_t hs_files,hs_total,ss_size;
hs_files=0;
hs_total=0;
fsize = bintools::filesize(path);
buffer = new char[static_cast<uint32_t>(fsize)];
file.read(buffer, static_cast<uint32_t>(fsize));
if (fsize < 0x14) //Filesize check (Static header contents)
ERROR("File to small");
//Check Signature
if (*reinterpret_cast<uint32_t*>(&buffer[0x0]) != 0x204C5348) ERROR("Invalid signature: "+hexString(*reinterpret_cast<uint32_t*>(&buffer[0x4])));
//Check Version
if (*reinterpret_cast<uint16_t*>(&buffer[0x4]) != 0x64) ERROR("Invalid version");
hs_files = *reinterpret_cast<uint32_t*>(&buffer[0xA]); //Read filename header size
hs_total = *reinterpret_cast<uint32_t*>(&buffer[0xE]); //Read total header size
ss_size = *reinterpret_cast<uint16_t*>(&buffer[0x12]); //Read start scenario name
if (hs_files > hs_total)
ERROR("Value error (hs_files > hs_total)");
if (fsize < hs_total)
ERROR("File to small (fsize < hs_total)");
if (fsize < 0x18+ss_size) //Filesize check
ERROR("File to small (fsize < 0x18+ss_size)");
//Read start scenario name
for (uint32_t i = 0;i < ss_size;i++)
{
if (buffer[0x14+i] == '\0')
{ss_name.resize(i);break;}
else
{ss_name += buffer[0x14+i];}
}
//Read scenario count
uint32_t s_count = *reinterpret_cast<uint32_t*>(&buffer[0x14+ss_size]); //Read scenario count
pc = 0x18+ss_size;
if (fsize < pc+s_count*2)
ERROR("File to small (fsize < pc+s_count)");
//Read scenario names
for (uint32_t i=0;i < s_count;i++)
{
Scenario s;
uint16_t size = *reinterpret_cast<uint16_t*>(&buffer[pc]); //Read scenario name
for (int j = 0;j < size;j++)
{
if (buffer[pc+2+j] == '\0')
{s.name.resize(j);break;}
else
{s.name += buffer[pc+2+j];}
}
s.offset = *reinterpret_cast<uint32_t*>(&buffer[hs_files+i*4]); //Read scenario offset
scenarios.push_back(s);
pc+=2+size;
}
LOG("Loaded "+path)
//Initalize components
r_manager = new ResourceManager(this);
this->debug = r_manager->getConfigVar("DEBUGGER.ENABLE") || force_debug;
debugger = new Debugger(this);
audio = new Audio(this);
}
bool operator != ( hexString Left, const char Right[]){return (Left.toInt() != hexString(Right).toInt());}
hexString operator - (const char * Left, const hexString Right){
hexString RetVal;
RetVal.intValue = hexString(Left).toInt() - Right.intValue;
return RetVal;
}
hexString operator - (const hexString Left, const unsigned long long int Right){
hexString RetVal;
RetVal.intValue = hexString(Left).toInt() - Right;
return RetVal;
}
hexString operator + (const hexString Left, const char * Right){
hexString RetVal;
RetVal.intValue = hexString(Left).toInt() + hexString(Right).toInt();
return RetVal;
}
hexString operator + (const hexString Left, const hexString Right){
hexString RetVal;
RetVal.intValue = hexString(Left).toInt() + Right.intValue;
return RetVal;
}
bool operator != ( const char Left[], hexString Right){return (hexString(Left).toInt() != Right.toInt());}
void hexString::operator -= (const std::string Right){
intValue -= hexString(Right).toInt();
setHexValue();
}
void ScenarioRunner::run()
{
Scenario scenario;
for (Scenario s : scenarios) if (s.name == ss_name) scenario = s;
if (scenario.name=="")
ERROR("Couldn't find start scenario '"+ss_name+"'");
c_scenario = scenario;
//List of operations
std::map<uint16_t,void(*)(ScenarioRunner* sr)> opcodes =
{
{0x0001,Operation::jump},
{0x0003,Operation::opcode_0003},
{0x0005,Operation::jump_conditinal},
{0x0080,Operation::message_show},
{0x0081,Operation::archive_graphics},
{0x0082,Operation::archive_music},
{0x0083,Operation::archive_sound},
{0x0084,Operation::scale_down},
{0x0085,Operation::window_init},
{0x0086,Operation::window_icon},
{0x0087,Operation::window_title},
{0x0088,Operation::scenario_title_set},
{0x0089,Operation::messagebox_init},
{0x008A,Operation::messagebox_bounds_init},
{0x008B,Operation::choicebox_init},
{0x008E,Operation::namebox_init},
{0x008F,Operation::namebox_bounds_init},
{0x0090,Operation::choicebox_on_init},
{0x0098,Operation::string_variable_set},
{0x0096,Operation::variable_set},
{0x0099,Operation::variable_add},
{0x009C,Operation::variable_sub},
{0x009E,Operation::variable_mul},
{0x00A0,Operation::variable_dev},
{0x00A2,Operation::variable_mod},
{0x00A3,Operation::scenario_enter},
{0x00C8,Operation::layer_set},
{0x00C9,Operation::layer_remove},
{0x00CA,Operation::layer_flush},
{0x00D4,Operation::layer_shake},
{0x00FA,Operation::play_bgm},
{0x00FB,Operation::stop_bgm},
{0x00FC,Operation::play_uncategorized},
{0x00FE,Operation::play_sfx},
{0x0107,Operation::message_clear},
{0x0104,Operation::message_hide},
{0x0109,Operation::avatar_set},
{0x010A,Operation::avatar_remove},
{0x0111,Operation::choice_add},
{0x0112,Operation::choices_show},
{0x012F,Operation::sleep},
{0x0131,Operation::sgf_load},
{0x0132,Operation::sgf_check_position},
{0x0133,Operation::sgf_check_click},
{0xFFFF,Operation::scenario_return}
};
//Set PC
pc = c_scenario.offset+4;
//Start debugger, if enabled
if (debuggingEnabled()) debugger->onStart();
for (;pc < c_scenario.offset+4+*reinterpret_cast<uint32_t*>(&buffer[c_scenario.offset]);)
{
if (terminated)
{
LOG("Termination requested.");
return;
}
uint16_t opcode = *reinterpret_cast<uint16_t*>(&buffer[pc]);
//Update title
if (window != nullptr)
{
window->setTitle("HadakaVM | Scenario: "+c_scenario.name+(debuggingEnabled() ? "@"+hexString(pc) : "")+(window->getFastmode()?" | Fast":""));
if (window->update().type==UpdateEventType::EXIT) Operation::exit(this);
}
pc+=2;
if (debuggingEnabled()) debugger->onInstruction(opcode);
if (opcodes.find(opcode)!=opcodes.end())
{
uint32_t old_pc = pc;
opcodes[opcode](this);
if (terminated)
{
LOG("Termination requested.");
return;
}
if (old_pc != pc) std::cout << std::endl;
continue;
}
//Stub handling
uint16_t p_count;
switch (opcode)
{
case 0x0085: case 0x00CB: case 0x0102: case 0x010A: case 0x012D: case 0x012E:
case 0x0134: case 0x0135: case 0x0136: case 0x0137: case 0x0162: case 0xFFFF:
case 0x0132:
p_count = 0; break;
case 0x0001: case 0x0081: case 0x0082: case 0x0083: case 0x0084: case 0x0086:
case 0x0087: case 0x0088: case 0x008C: case 0x0093: case 0x0094: case 0x0095:
case 0x00A3: case 0x00FB: case 0x00FF: case 0x0103: case 0x0112: case 0x0116:
case 0x0127: case 0x0129: case 0x0133: case 0x0138: case 0x0161:
p_count = 1; break;
case 0x0002: case 0x0003: case 0x008D: case 0x0090: case 0x0096: case 0x0098:
case 0x0099: case 0x009C: case 0x009E: case 0x00A0: case 0x00A2: case 0x00A6:
case 0x00CA: case 0x00D6: case 0x00D9: case 0x00FA: case 0x0104: case 0x0107:
case 0x0111: case 0x011D: case 0x0121: case 0x012F: case 0x015E: case 0x0190:
p_count = 2; break;
case 0x00C9: case 0x00D5: case 0x00D7: case 0x00DA: case 0x00FC: case 0x00FE:
case 0x0109: case 0x0126: case 0x0131:
p_count = 3; break;
case 0x0004: case 0x0005: case 0x0089: case 0x008A: case 0x008E: case 0x008F:
case 0x00A4: case 0x00D4: case 0x0110: case 0x0118: case 0x0120: case 0x0123:
case 0x015F: case 0x0160:
p_count = 4; break;
case 0x0092:
p_count = 5; break;
case 0x008B: case 0x0100: case 0x011C:
p_count = 6; break;
case 0x00C8: case 0x00D0: case 0x010E: case 0x0113: case 0x0119: case 0x011A:
case 0x011B: case 0x0128:
p_count = 7; break;
case 0x011E: case 0x011F: case 0x012A: case 0x012B:
p_count = 8; break;
default:
ERROR("Unimplemented Operation: "+hexString(opcode));
};
WARN("Stub Operation: "+hexString(opcode)+"; Length = "+hexString(p_count));
for (uint16_t i=0;i < p_count;i++)
{
getParameter();
}
if (p_count > 0) std::cout << std::endl;
}
if (c_scenario.name == ss_name)
ERROR("Reached end of start scenario, this shouldn't happen :/");
}
hexString operator - (const hexString Left, const std::string Right){
hexString RetVal;
RetVal.intValue = hexString(Left).toInt() - hexString(Right).toInt();
return RetVal;
}
bool operator >= ( std::string Left, hexString Right){return (hexString(Left).toInt() >= Right.toInt());}
