int main(int argc, char *argv[]) {
if (!loadExe("nhc.exe") ||
!validateMd5())
return 1;
FILE *datFile;
hitRectLists.loadListVector(hitRectListOffsets);
rectLists.loadListVector(rectListOffsets);
messageLists.loadListVector(messageListOffsets);
navigationLists.loadListVector(navigationListOffsets);
sceneInfo140Items.loadVector(sceneInfo140Offsets);
sceneInfo2700Items.loadVector(sceneInfo2700Offsets);
datFile = fopen("neverhood.dat", "wb");
writeUint32LE(datFile, 0x11223344); // Some magic
writeUint32LE(datFile, DAT_VERSION);
messageLists.saveListVector(datFile);
rectLists.saveListVector(datFile);
hitRectLists.saveListVector(datFile);
navigationLists.saveListVector(datFile);
sceneInfo140Items.saveVector(datFile);
sceneInfo2700Items.saveVector(datFile);
fclose(datFile);
printf("Done.\n");
return 0;
}
bool PAKFile::saveFile(const char *file) {
if (!_fileList)
return true;
FILE *f = fopen(file, "wb");
if (!f) {
error("couldn't open file '%s' for writing", file);
return false;
}
// TODO: implement error handling
uint32 startAddr = _fileList->getTableSize()+5+4;
static const char *zeroName = "\0\0\0\0\0";
uint32 curAddr = startAddr;
for (FileList *cur = _fileList; cur; cur = cur->next) {
if (_isAmiga)
writeUint32BE(f, curAddr);
else
writeUint32LE(f, curAddr);
fwrite(cur->filename, 1, strlen(cur->filename) + 1, f);
curAddr += cur->size;
}
if (_isAmiga)
writeUint32BE(f, curAddr);
else
writeUint32LE(f, curAddr);
fwrite(zeroName, 1, 5, f);
for (FileList *cur = _fileList; cur; cur = cur->next)
fwrite(cur->data, 1, cur->size, f);
fclose(f);
return true;
}
void saveList(FILE *fd) {
writeUint32LE(fd, id);
writeUint32LE(fd, getCount());
for (int i = 0; i < getCount(); i++) {
items[i].save(fd);
}
}
void save(FILE *fd) {
writeUint32LE(fd, fileHash);
writeUint32LE(fd, leftSmackerFileHash);
writeUint32LE(fd, rightSmackerFileHash);
writeUint32LE(fd, middleSmackerFileHash);
writeByte(fd, interactive);
writeByte(fd, middleFlag);
writeUint32LE(fd, mouseCursorFileHash);
}
void save(FILE *fd) {
writeUint32LE(fd, id);
writeUint32LE(fd, bgFilename1);
writeUint32LE(fd, bgFilename2);
writeUint32LE(fd, txFilename);
writeUint32LE(fd, bgFilename3);
writeByte(fd, xPosIndex);
writeByte(fd, count);
}
void save(FILE *fd) {
writeUint16LE(fd, x1);
writeUint16LE(fd, y1);
writeUint16LE(fd, x2);
writeUint16LE(fd, y2);
writeUint32LE(fd, messageListOffset);
}
void MfcArchive::writeObject(CObject *obj) {
if (obj == NULL) {
writeUint16LE(0);
} else if (_objectHash.contains(obj)) {
int32 idx = _objectHash[obj];
if (idx < 0x7fff) {
writeUint16LE(idx);
} else {
writeUint16LE(0x7fff);
writeUint32LE(idx);
}
} else {
writeUint16LE(0xffff); // New class
_objectHash[obj] = _lastIndex++;
writeUint16LE(1); // schema
switch (obj->_objtype) {
case kObjTypeGameVar:
writePascalString(lookupObjectId(kGameVar), true); // Two byte counter
break;
default:
error("Unhandled save for object type: %d", obj->_objtype);
}
obj->save(*this);
}
}
void save(FILE *fd) {
writeUint32LE(fd, id);
writeUint32LE(fd, bgFilename);
writeUint32LE(fd, class437Filename);
writeUint32LE(fd, dataResourceFilename);
writeUint32LE(fd, pointListName);
writeUint32LE(fd, rectListName);
writeUint32LE(fd, exPaletteFilename2);
writeUint32LE(fd, exPaletteFilename1);
writeUint32LE(fd, mouseCursorFilename);
writeUint16LE(fd, which1);
writeUint16LE(fd, which2);
}
void save(FILE *fd) {
writeUint16LE(fd, x1);
writeUint16LE(fd, y1);
writeUint16LE(fd, x2);
writeUint16LE(fd, y2);
writeUint32LE(fd, subRectItems.size());
for (uint32 j = 0; j < subRectItems.size(); j++)
subRectItems[j].save(fd);
}
int main(int argc, char **argv) {
bitcoinTransaction *transaction;
int offset = 0;
int result;
int version = DEFAULT_VERSION;
int lockTime = DEFAULT_LOCKTIME;
int i;
int currentIndex = 1;
bitcoinInput *lastInput = NULL;
unsigned char *buffer;
if (argc < 6) {
fprintf(stderr, "Usage : %s [version (or empty for default)] [locktime (or empty for default)] [dongle output data] [trusted input 1] [input script 1] ... [last trusted input] [last input script]\n", argv[0]);
return 0;
}
if (((argc - 4) % 2) != 0) {
fprintf(stderr, "Invalid number of trusted input / input script parameters\n");
return 0;
}
if (strlen(argv[1]) != 0) {
version = strtol(argv[1], NULL, 10);
if (version < 0) {
fprintf(stderr, "Invalid version\n");
return 0;
}
}
if (strlen(argv[2]) != 0) {
lockTime = strtol(argv[2], NULL, 10);
if (lockTime < 0) {
fprintf(stderr, "Invalid lockTime\n");
return 0;
}
}
transaction = (bitcoinTransaction*)malloc(sizeof(bitcoinTransaction));
if (transaction == NULL) {
fprintf(stderr, "Failed to allocate transaction\n");
return 0;
}
memset(transaction, 0, sizeof(bitcoinTransaction));
writeUint32LE(transaction->version, version);
for (i=4; i<argc; i += 2) {
unsigned char trustedInput[56];
bitcoinInput *input;
input = (bitcoinInput*)malloc(sizeof(bitcoinInput));
if (input == NULL) {
fprintf(stderr, "Failed to allocate input\n");
freeTransaction(transaction);
return 0;
}
memset(input, 0, sizeof(bitcoinInput));
result = hexToBin(argv[i], trustedInput, sizeof(trustedInput));
if (result <= 0) {
fprintf(stderr, "Invalid trustedInput %d\n", currentIndex);
freeTransaction(transaction);
free(input);
return 0;
}
if (lastInput == NULL) {
transaction->inputs = input;
}
else {
lastInput->next = input;
}
input->scriptLength = (strlen(argv[i + 1]) / 2);
input->script = (unsigned char*)malloc(input->scriptLength);
if (input->script == NULL) {
fprintf(stderr, "Failed to allocate script\n");
freeTransaction(transaction);
free(input);
return 0;
}
result = hexToBin(argv[i + 1], input->script, input->scriptLength);
if (result <= 0) {
fprintf(stderr, "Invalid script %d\n", currentIndex);
freeTransaction(transaction);
free(input);
return 0;
}
memcpy(input->prevOut, trustedInput + 4, sizeof(input->prevOut));
memset(input->sequence, DEFAULT_SEQUENCE, sizeof(input->sequence));
lastInput = input;
currentIndex++;
}
buffer = (unsigned char*)malloc(BUFFER_SIZE);
if (buffer == NULL) {
fprintf(stderr, "Failed to allocate output buffer\n");
freeTransaction(transaction);
}
offset = writeTransactionWithoutOutputLocktime(transaction, buffer, BUFFER_SIZE);
freeTransaction(transaction);
result = hexToBin(argv[3], buffer + offset, BUFFER_SIZE - offset);
if (result <= 0) {
fprintf(stderr, "Invalid output\n");
freeTransaction(transaction);
free(buffer);
}
offset += result;
writeUint32LE(buffer + offset, lockTime);
offset += 4;
printf("Transaction : ");
displayBinary(buffer, offset);
free(buffer);
return 1;
}
void saveVector(FILE *fd) {
writeUint32LE(fd, items.size());
for (typename std::vector<ITEMCLASS>::iterator it = items.begin(); it != items.end(); it++) {
(*it).save(fd);
}
}
void saveListVector(FILE *fd) {
writeUint32LE(fd, lists.size());
for (typename std::vector<LISTCLASS*>::iterator it = lists.begin(); it != lists.end(); it++) {
(*it)->saveList(fd);
}
}
void save(FILE *fd) {
writeUint16LE(fd, messageNum);
writeUint32LE(fd, messageParam);
}
void SaveFileWriteStream::writeRect(const Common::Rect &v) {
writeUint32LE(v.left);
writeUint32LE(v.top);
writeUint32LE(v.right);
writeUint32LE(v.bottom);
}
void SaveFileWriteStream::writeBool(bool v) {
writeUint32LE(v);
}
void SaveFileWriteStream::writeInt(int v) {
writeUint32LE(v);
}
