mirror of
https://github.com/DrBeef/Raze.git
synced 2024-12-15 23:21:21 +00:00
932 lines
26 KiB
C++
932 lines
26 KiB
C++
/**
|
|
* BUILD ART file editing tool
|
|
* @author Jonathon Fowler
|
|
* @license Artistic License 2.0 (http://www.perlfoundation.org/artistic_license_2_0)
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <cstdlib>
|
|
|
|
#include "compat.h"
|
|
|
|
using namespace std;
|
|
|
|
void usage()
|
|
{
|
|
cout << "BUILD ART file editing tool" << endl;
|
|
cout << "Copyright (C) 2008 Jonathon Fowler <jf@jonof.id.au>" << endl;
|
|
cout << "Released under the Artistic License 2.0" << endl;
|
|
cout << endl;
|
|
cout << " arttool create [options]" << endl;
|
|
cout << " -f <filenum> Selects which numbered ART file to create (default 0)" << endl;
|
|
cout << " -o <offset> Specifies the first tile in the file (default 0)" << endl;
|
|
cout << " -n <ntiles> The number of tiles for the art file (default 256)" << endl;
|
|
cout << " Creates an empty ART file named 'tilesXXX.art'" << endl;
|
|
cout << endl;
|
|
cout << " arttool addtile [options] <tilenum> <filename>" << endl;
|
|
cout << " -x <pixels> X-centre" << endl;
|
|
cout << " -y <pixels> Y-centre" << endl;
|
|
cout << " -ann <frames> Animation frame span" << endl;
|
|
cout << " -ant <type> Animation type (0=none, 1=oscillate, 2=forward, 3=reverse)" << endl;
|
|
cout << " -ans <speed> Animation speed" << endl;
|
|
cout << " Adds a tile to the 'tilesXXX.art' set from a TGA or PCX source" << endl;
|
|
cout << endl;
|
|
cout << " arttool rmtile <tilenum>" << endl;
|
|
cout << " Removes a tile from the 'tilesXXX.art' set" << endl;
|
|
cout << endl;
|
|
cout << " arttool tileprop [options] <tilenum>" << endl;
|
|
cout << " -x <pixels> X-centre" << endl;
|
|
cout << " -y <pixels> Y-centre" << endl;
|
|
cout << " -ann <frames> Animation frame span, may be -ve" << endl;
|
|
cout << " -ant <type> Animation type (0=none, 1=oscillate, 2=forward, 3=reverse)" << endl;
|
|
cout << " -ans <speed> Animation speed" << endl;
|
|
cout << " Changes tile properties" << endl;
|
|
cout << endl;
|
|
}
|
|
|
|
class ARTFile {
|
|
private:
|
|
string filename_;
|
|
long localtilestart_;
|
|
long localtileend_;
|
|
short * tilesizx_;
|
|
short * tilesizy_;
|
|
long * picanm_;
|
|
|
|
// for removing or replacing tile data
|
|
int markprelength_, markskiplength_, markpostlength_;
|
|
char * insert_;
|
|
int insertlen_;
|
|
|
|
void writeShort(ofstream &ofs, short s)
|
|
{
|
|
char d[2] = { s&255, (s>>8)&255 };
|
|
ofs.write(d, 2);
|
|
}
|
|
|
|
void writeLong(ofstream &ofs, long l)
|
|
{
|
|
char d[4] = { l&255, (l>>8)&255, (l>>16)&255, (l>>24)&255 };
|
|
ofs.write(d, 4);
|
|
}
|
|
|
|
short readShort(ifstream &ifs)
|
|
{
|
|
unsigned char d[2];
|
|
unsigned short s;
|
|
ifs.read((char *) d, 2);
|
|
s = (unsigned short)d[0];
|
|
s |= (unsigned short)d[1] << 8;
|
|
return (short)s;
|
|
}
|
|
|
|
long readLong(ifstream &ifs)
|
|
{
|
|
unsigned char d[4];
|
|
unsigned long l;
|
|
ifs.read((char *) d, 4);
|
|
l = (unsigned long)d[0];
|
|
l |= (unsigned long)d[1] << 8;
|
|
l |= (unsigned long)d[2] << 16;
|
|
l |= (unsigned long)d[3] << 24;
|
|
return (long)l;
|
|
}
|
|
|
|
void dispose()
|
|
{
|
|
if (tilesizx_) delete [] tilesizx_;
|
|
if (tilesizy_) delete [] tilesizy_;
|
|
if (picanm_) delete [] picanm_;
|
|
if (insert_) delete [] insert_;
|
|
|
|
insert_ = 0;
|
|
insertlen_ = 0;
|
|
}
|
|
|
|
void load()
|
|
{
|
|
ifstream infile(filename_.c_str(), ios::in | ios::binary);
|
|
int i, ntiles;
|
|
|
|
if (infile.is_open()) {
|
|
do {
|
|
if (readLong(infile) != 1) {
|
|
break;
|
|
}
|
|
readLong(infile); // skip the numtiles
|
|
dispose();
|
|
|
|
localtilestart_ = readLong(infile);
|
|
localtileend_ = readLong(infile);
|
|
ntiles = localtileend_ - localtilestart_ + 1;
|
|
|
|
tilesizx_ = new short[ntiles];
|
|
tilesizy_ = new short[ntiles];
|
|
picanm_ = new long[ntiles];
|
|
|
|
for (i = 0; i < ntiles; i++) {
|
|
tilesizx_[i] = readShort(infile);
|
|
}
|
|
for (i = 0; i < ntiles; i++) {
|
|
tilesizy_[i] = readShort(infile);
|
|
}
|
|
for (i = 0; i < ntiles; i++) {
|
|
picanm_[i] = readLong(infile);
|
|
}
|
|
|
|
} while (0);
|
|
|
|
infile.close();
|
|
}
|
|
}
|
|
|
|
public:
|
|
ARTFile(string filename)
|
|
: filename_(filename), localtilestart_(0), localtileend_(-1),
|
|
tilesizx_(0), tilesizy_(0), picanm_(0),
|
|
markprelength_(0), markskiplength_(0), markpostlength_(0),
|
|
insert_(0), insertlen_(0)
|
|
{
|
|
load();
|
|
}
|
|
|
|
~ARTFile()
|
|
{
|
|
dispose();
|
|
}
|
|
|
|
/**
|
|
* Sets up for an empty file
|
|
* @param start the starting tile
|
|
* @param ntiles the number of tiles total
|
|
*/
|
|
void init(int start, int ntiles)
|
|
{
|
|
dispose();
|
|
|
|
localtilestart_ = start;
|
|
localtileend_ = start + ntiles - 1;
|
|
tilesizx_ = new short[ntiles];
|
|
tilesizy_ = new short[ntiles];
|
|
picanm_ = new long[ntiles];
|
|
|
|
memset(tilesizx_, 0, sizeof(short)*ntiles);
|
|
memset(tilesizy_, 0, sizeof(short)*ntiles);
|
|
memset(picanm_, 0, sizeof(long)*ntiles);
|
|
|
|
markprelength_ = 0;
|
|
markskiplength_ = 0;
|
|
markpostlength_ = 0;
|
|
insert_ = 0;
|
|
insertlen_ = 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of tiles in the loaded file
|
|
* @return 0 means no file loaded
|
|
*/
|
|
int getNumTiles()
|
|
{
|
|
return (localtileend_ - localtilestart_ + 1);
|
|
}
|
|
|
|
int getFirstTile()
|
|
{
|
|
return localtilestart_;
|
|
}
|
|
|
|
int getLastTile()
|
|
{
|
|
return localtileend_;
|
|
}
|
|
|
|
void removeTile(int tile)
|
|
{
|
|
int i, end;
|
|
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
end = localtileend_ - tile;
|
|
tile -= localtilestart_;
|
|
|
|
markprelength_ = markpostlength_ = 0;
|
|
|
|
for (i = 0; i < tile; i++) {
|
|
markprelength_ += tilesizx_[i] * tilesizy_[i];
|
|
}
|
|
markskiplength_ = tilesizx_[tile] * tilesizy_[tile];
|
|
for (i = tile + 1; i <= end; i++) {
|
|
markpostlength_ += tilesizx_[i] * tilesizy_[i];
|
|
}
|
|
|
|
tilesizx_[tile] = tilesizy_[tile] = 0;
|
|
}
|
|
|
|
void replaceTile(int tile, char * replace, int replacelen)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
removeTile(tile);
|
|
|
|
insert_ = replace;
|
|
insertlen_ = replacelen;
|
|
}
|
|
|
|
void setTileSize(int tile, int x, int y)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
tilesizx_[tile] = x;
|
|
tilesizy_[tile] = y;
|
|
}
|
|
|
|
void setXOfs(int tile, int x)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
picanm_[tile] &= ~(255<<8);
|
|
picanm_[tile] |= ((long)((unsigned char)x) << 8);
|
|
}
|
|
|
|
void setYOfs(int tile, int y)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
picanm_[tile] &= ~(255<<16);
|
|
picanm_[tile] |= ((long)((unsigned char)y) << 16);
|
|
}
|
|
|
|
void setAnimType(int tile, int type)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
picanm_[tile] &= ~(3<<6);
|
|
picanm_[tile] |= ((long)(type&3) << 6);
|
|
}
|
|
|
|
void setAnimFrames(int tile, int frames)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
picanm_[tile] &= ~(63);
|
|
picanm_[tile] |= ((long)(frames&63));
|
|
}
|
|
|
|
void setAnimSpeed(int tile, int speed)
|
|
{
|
|
if (tile < localtilestart_ || tile > localtileend_) {
|
|
return;
|
|
}
|
|
|
|
tile -= localtilestart_;
|
|
picanm_[tile] &= ~(15<<24);
|
|
picanm_[tile] |= ((long)(speed&15) << 24);
|
|
}
|
|
|
|
int write()
|
|
{
|
|
string tmpfilename(filename_ + ".arttooltmp");
|
|
ofstream outfile(tmpfilename.c_str(), ios::out | ios::trunc | ios::binary);
|
|
ifstream infile(filename_.c_str(), ios::in | ios::binary);
|
|
int i, left;
|
|
char blk[4096];
|
|
|
|
if (!infile.is_open() && (markprelength_ > 0 || markskiplength_ > 0 || markpostlength_ > 0)) {
|
|
return -1; // couldn't open the original file for copying
|
|
} else if (infile.is_open()) {
|
|
// skip to the start of the existing ART data
|
|
int ofs = 4+4+4+4+(2+2+4)*(localtileend_-localtilestart_+1);
|
|
infile.seekg(ofs, ios::cur);
|
|
}
|
|
|
|
// write a header to the temporary file
|
|
writeLong(outfile, 1); // version
|
|
writeLong(outfile, 0); // numtiles
|
|
writeLong(outfile, localtilestart_);
|
|
writeLong(outfile, localtileend_);
|
|
for (int i = 0; i < localtileend_ - localtilestart_ + 1; i++) {
|
|
writeShort(outfile, tilesizx_[i]);
|
|
}
|
|
for (int i = 0; i < localtileend_ - localtilestart_ + 1; i++) {
|
|
writeShort(outfile, tilesizy_[i]);
|
|
}
|
|
for (int i = 0; i < localtileend_ - localtilestart_ + 1; i++) {
|
|
writeLong(outfile, picanm_[i]);
|
|
}
|
|
|
|
// copy the existing leading tile data to be kept
|
|
left = markprelength_;
|
|
while (left > 0) {
|
|
i = left;
|
|
if ((unsigned int)i > sizeof(blk)) {
|
|
i = sizeof(blk);
|
|
}
|
|
infile.read(blk, i);
|
|
outfile.write(blk, i);
|
|
left -= i;
|
|
}
|
|
|
|
// insert the replacement data
|
|
if (insertlen_ > 0) {
|
|
outfile.write(insert_, insertlen_);
|
|
}
|
|
|
|
if (markskiplength_ > 0) {
|
|
infile.seekg(markskiplength_, ios::cur);
|
|
}
|
|
|
|
// copy the existing trailing tile data to be kept
|
|
left = markpostlength_;
|
|
while (left > 0) {
|
|
i = left;
|
|
if ((unsigned int)i > sizeof(blk)) {
|
|
i = sizeof(blk);
|
|
}
|
|
infile.read(blk, i);
|
|
outfile.write(blk, i);
|
|
left -= i;
|
|
}
|
|
|
|
// close our files
|
|
if (infile.is_open()) {
|
|
infile.close();
|
|
}
|
|
outfile.close();
|
|
|
|
// replace it with the new one
|
|
unlink(filename_.c_str());
|
|
rename(tmpfilename.c_str(), filename_.c_str());
|
|
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Decodes a PCX file directly to BUILD's column-major pixel order
|
|
* @param data the raw file data
|
|
* @param datalen the length of the raw file data
|
|
* @param imgdata receives a pointer to the decoded image data
|
|
* @param imgdataw receives the decoded image width
|
|
* @param imgdatah receives the decoded image height
|
|
* @return 0 on success, 1 if the format is invalid
|
|
*/
|
|
int loadimage_pcx(unsigned char * data, int datalen ATTRIBUTE((unused)), char ** imgdata, int& imgdataw, int& imgdatah)
|
|
{
|
|
if (data[0] != 10 ||
|
|
data[1] != 5 ||
|
|
data[2] != 1 ||
|
|
data[3] != 8 ||
|
|
data[64] != 0 ||
|
|
data[65] != 1) {
|
|
return 1;
|
|
}
|
|
|
|
int bpl = data[66] + ((int)data[67] << 8);
|
|
int x, y, repeat, colour;
|
|
unsigned char *wptr, *rptr;
|
|
|
|
imgdataw = (data[8] + ((int)data[9] << 8)) - (data[4] + ((int)data[5] << 8)) + 1;
|
|
imgdatah = (data[10] + ((int)data[11] << 8)) - (data[6] + ((int)data[7] << 8)) + 1;
|
|
|
|
*imgdata = new char [imgdataw * imgdatah];
|
|
|
|
rptr = data + 128;
|
|
for (y = 0; y < imgdatah; y++) {
|
|
wptr = (unsigned char *) (*imgdata + y);
|
|
x = 0;
|
|
do {
|
|
repeat = *(rptr++);
|
|
if ((repeat & 192) == 192) {
|
|
colour = *(rptr++);
|
|
repeat = repeat & 63;
|
|
} else {
|
|
colour = repeat;
|
|
repeat = 1;
|
|
}
|
|
|
|
for (; repeat > 0; repeat--, x++) {
|
|
if (x < imgdataw) {
|
|
*wptr = (unsigned char) colour;
|
|
wptr += imgdatah; // next column
|
|
}
|
|
}
|
|
} while (x < bpl);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Loads a tile from a picture file into memory
|
|
* @param filename the filename
|
|
* @param imgdata receives a pointer to the decoded image data
|
|
* @param imgdataw receives the decoded image width
|
|
* @param imgdatah receives the decoded image height
|
|
* @return 0 on success
|
|
*/
|
|
int loadimage(string filename, char ** imgdata, int& imgdataw, int& imgdatah)
|
|
{
|
|
ifstream infile(filename.c_str(), ios::in | ios::binary);
|
|
unsigned char * data = 0;
|
|
int datalen = 0, err = 0;
|
|
|
|
if (!infile.is_open()) {
|
|
return 1;
|
|
}
|
|
|
|
infile.seekg(0, ios::end);
|
|
datalen = infile.tellg();
|
|
infile.seekg(0, ios::beg);
|
|
|
|
data = new unsigned char [datalen];
|
|
infile.read((char *) data, datalen);
|
|
infile.close();
|
|
|
|
err = loadimage_pcx(data, datalen, imgdata, imgdataw, imgdatah);
|
|
|
|
delete [] data;
|
|
|
|
return err;
|
|
}
|
|
|
|
class Operation {
|
|
protected:
|
|
string makefilename(int n)
|
|
{
|
|
string filename("tilesXXX.art");
|
|
filename[5] = '0' + (n / 100) % 10;
|
|
filename[6] = '0' + (n / 10) % 10;
|
|
filename[7] = '0' + (n / 1) % 10;
|
|
return filename;
|
|
}
|
|
|
|
public:
|
|
typedef enum {
|
|
ERR_NO_ERROR = 0,
|
|
ERR_BAD_OPTION = 1,
|
|
ERR_BAD_VALUE = 2,
|
|
ERR_TOO_MANY_PARAMS = 3,
|
|
ERR_NO_ART_FILE = 4,
|
|
ERR_INVALID_IMAGE = 5,
|
|
} Result;
|
|
|
|
static char const * translateResult(Result r)
|
|
{
|
|
switch (r) {
|
|
case ERR_NO_ERROR: return "no error";
|
|
case ERR_BAD_OPTION: return "bad option";
|
|
case ERR_BAD_VALUE: return "bad value";
|
|
case ERR_TOO_MANY_PARAMS: return "too many parameters given";
|
|
case ERR_NO_ART_FILE: return "no ART file was found";
|
|
case ERR_INVALID_IMAGE: return "a corrupt or unrecognised image was given";
|
|
default: return "unknown error";
|
|
}
|
|
}
|
|
|
|
virtual ~Operation()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Sets an option
|
|
* @param opt the option name
|
|
* @param value the option value
|
|
* @return a value from the Result enum
|
|
*/
|
|
virtual Result setOption(string opt, string value) = 0;
|
|
|
|
/**
|
|
* Sets a parameter from the unnamed sequence
|
|
* @param number the parameter number
|
|
* @param value the parameter value
|
|
* @return a value from the Result enum
|
|
*/
|
|
virtual Result setParameter(int number, string value) = 0;
|
|
|
|
/**
|
|
* Do the operation
|
|
* @return a value from the Result enum
|
|
*/
|
|
virtual Result perform() = 0;
|
|
};
|
|
|
|
class CreateOp : public Operation {
|
|
private:
|
|
int filen_, offset_, ntiles_;
|
|
public:
|
|
CreateOp() : filen_(0), offset_(0), ntiles_(256) { }
|
|
|
|
virtual Result setOption(string opt, string value)
|
|
{
|
|
if (opt == "f") {
|
|
filen_ = atoi(value.c_str());
|
|
if (filen_ < 0 || filen_ > 999) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "o") {
|
|
offset_ = atoi(value.c_str());
|
|
if (offset_ < 0) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "n") {
|
|
ntiles_ = atoi(value.c_str());
|
|
if (ntiles_ < 1) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else {
|
|
return ERR_BAD_OPTION;
|
|
}
|
|
return ERR_NO_ERROR;
|
|
}
|
|
|
|
virtual Result setParameter(int number ATTRIBUTE((unused)), string value ATTRIBUTE((unused)))
|
|
{
|
|
return ERR_TOO_MANY_PARAMS;
|
|
}
|
|
|
|
virtual Result perform()
|
|
{
|
|
ARTFile art(makefilename(filen_));
|
|
|
|
art.init(offset_, ntiles_);
|
|
art.write();
|
|
|
|
return ERR_NO_ERROR;
|
|
}
|
|
};
|
|
|
|
class AddTileOp : public Operation {
|
|
private:
|
|
int xofs_, yofs_;
|
|
int animframes_, animtype_, animspeed_;
|
|
int tilenum_;
|
|
string filename_;
|
|
public:
|
|
AddTileOp()
|
|
: xofs_(0), yofs_(0),
|
|
animframes_(0), animtype_(0), animspeed_(0),
|
|
tilenum_(-1), filename_("")
|
|
{ }
|
|
|
|
virtual Result setOption(string opt, string value)
|
|
{
|
|
if (opt == "x") {
|
|
xofs_ = atoi(value.c_str());
|
|
} else if (opt == "y") {
|
|
yofs_ = atoi(value.c_str());
|
|
} else if (opt == "ann") {
|
|
animframes_ = atoi(value.c_str());
|
|
if (animframes_ < 0 || animframes_ > 63) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "ant") {
|
|
animtype_ = atoi(value.c_str());
|
|
if (animtype_ < 0 || animtype_ > 3) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "ans") {
|
|
animspeed_ = atoi(value.c_str());
|
|
if (animspeed_ < 0 || animspeed_ > 15) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else {
|
|
return ERR_BAD_OPTION;
|
|
}
|
|
return ERR_NO_ERROR;
|
|
}
|
|
|
|
virtual Result setParameter(int number, string value)
|
|
{
|
|
switch (number) {
|
|
case 0:
|
|
tilenum_ = atoi(value.c_str());
|
|
return ERR_NO_ERROR;
|
|
case 1:
|
|
filename_ = value;
|
|
return ERR_NO_ERROR;
|
|
default:
|
|
return ERR_TOO_MANY_PARAMS;
|
|
}
|
|
}
|
|
|
|
virtual Result perform()
|
|
{
|
|
int tilesperfile = 0, nextstart = 0;
|
|
int filenum = 0;
|
|
char * imgdata = 0;
|
|
int imgdataw = 0, imgdatah = 0;
|
|
|
|
// open the first art file to get the file size used by default
|
|
{
|
|
ARTFile art(makefilename(0));
|
|
tilesperfile = art.getNumTiles();
|
|
if (tilesperfile == 0) {
|
|
return ERR_NO_ART_FILE;
|
|
}
|
|
}
|
|
|
|
// load the tile image into memory
|
|
switch (loadimage(filename_, &imgdata, imgdataw, imgdatah)) {
|
|
case 0: break; // win
|
|
default: return ERR_INVALID_IMAGE;
|
|
}
|
|
|
|
// open art files until we find one that encompasses the range we need
|
|
// and when we find it, make the change
|
|
for (filenum = 0; filenum < 1000; filenum++) {
|
|
ARTFile art(makefilename(filenum));
|
|
bool dirty = false, done = false;
|
|
|
|
if (art.getNumTiles() == 0) {
|
|
// no file exists, so we treat it as though it does
|
|
art.init(nextstart, tilesperfile);
|
|
dirty = true;
|
|
}
|
|
|
|
if (tilenum_ >= art.getFirstTile() && tilenum_ <= art.getLastTile()) {
|
|
art.replaceTile(tilenum_, imgdata, imgdataw * imgdatah);
|
|
art.setTileSize(tilenum_, imgdataw, imgdatah);
|
|
art.setXOfs(tilenum_, xofs_);
|
|
art.setYOfs(tilenum_, yofs_);
|
|
art.setAnimFrames(tilenum_, animframes_);
|
|
art.setAnimSpeed(tilenum_, animspeed_);
|
|
art.setAnimType(tilenum_, animtype_);
|
|
done = true;
|
|
dirty = true;
|
|
|
|
imgdata = 0; // ARTFile.replaceTile took ownership of the pointer
|
|
}
|
|
|
|
nextstart += art.getNumTiles();
|
|
|
|
if (dirty) {
|
|
art.write();
|
|
}
|
|
if (done) {
|
|
return ERR_NO_ERROR;
|
|
}
|
|
}
|
|
|
|
if (imgdata) {
|
|
delete [] imgdata;
|
|
}
|
|
|
|
return ERR_NO_ART_FILE;
|
|
}
|
|
};
|
|
|
|
class RmTileOp : public Operation {
|
|
private:
|
|
int tilenum_;
|
|
public:
|
|
RmTileOp() : tilenum_(-1) { }
|
|
|
|
virtual Result setOption(string opt ATTRIBUTE((unused)), string value ATTRIBUTE((unused)))
|
|
{
|
|
return ERR_BAD_OPTION;
|
|
}
|
|
|
|
virtual Result setParameter(int number, string value)
|
|
{
|
|
switch (number) {
|
|
case 0:
|
|
tilenum_ = atoi(value.c_str());
|
|
return ERR_NO_ERROR;
|
|
default:
|
|
return ERR_TOO_MANY_PARAMS;
|
|
}
|
|
}
|
|
|
|
virtual Result perform()
|
|
{
|
|
int filenum = 0;
|
|
|
|
// open art files until we find one that encompasses the range we need
|
|
// and when we find it, remove the tile
|
|
for (filenum = 0; filenum < 1000; filenum++) {
|
|
ARTFile art(makefilename(filenum));
|
|
|
|
if (art.getNumTiles() == 0) {
|
|
// no file exists, so give up
|
|
break;
|
|
}
|
|
|
|
if (tilenum_ >= art.getFirstTile() && tilenum_ <= art.getLastTile()) {
|
|
art.removeTile(tilenum_);
|
|
art.write();
|
|
return ERR_NO_ERROR;
|
|
}
|
|
}
|
|
|
|
return ERR_NO_ART_FILE;
|
|
}
|
|
};
|
|
|
|
class TilePropOp : public Operation {
|
|
private:
|
|
int xofs_, yofs_;
|
|
int animframes_, animtype_, animspeed_;
|
|
int tilenum_;
|
|
|
|
int settings_;
|
|
|
|
enum {
|
|
SET_XOFS = 1,
|
|
SET_YOFS = 2,
|
|
SET_ANIMFRAMES = 4,
|
|
SET_ANIMTYPE = 8,
|
|
SET_ANIMSPEED = 16,
|
|
};
|
|
public:
|
|
TilePropOp()
|
|
: xofs_(0), yofs_(0),
|
|
animframes_(0), animtype_(0), animspeed_(0),
|
|
tilenum_(-1), settings_(0)
|
|
{ }
|
|
|
|
virtual Result setOption(string opt, string value)
|
|
{
|
|
if (opt == "x") {
|
|
xofs_ = atoi(value.c_str());
|
|
settings_ |= SET_XOFS;
|
|
} else if (opt == "y") {
|
|
yofs_ = atoi(value.c_str());
|
|
settings_ |= SET_YOFS;
|
|
} else if (opt == "ann") {
|
|
animframes_ = atoi(value.c_str());
|
|
settings_ |= SET_ANIMFRAMES;
|
|
if (animframes_ < 0 || animframes_ > 63) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "ant") {
|
|
animtype_ = atoi(value.c_str());
|
|
settings_ |= SET_ANIMTYPE;
|
|
if (animtype_ < 0 || animtype_ > 3) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else if (opt == "ans") {
|
|
animspeed_ = atoi(value.c_str());
|
|
settings_ |= SET_ANIMSPEED;
|
|
if (animspeed_ < 0 || animspeed_ > 15) {
|
|
return ERR_BAD_VALUE;
|
|
}
|
|
} else {
|
|
return ERR_BAD_OPTION;
|
|
}
|
|
return ERR_NO_ERROR;
|
|
}
|
|
|
|
virtual Result setParameter(int number, string value)
|
|
{
|
|
switch (number) {
|
|
case 0:
|
|
tilenum_ = atoi(value.c_str());
|
|
return ERR_NO_ERROR;
|
|
default:
|
|
return ERR_TOO_MANY_PARAMS;
|
|
}
|
|
}
|
|
|
|
virtual Result perform()
|
|
{
|
|
int filenum = 0;
|
|
|
|
if (settings_ == 0) {
|
|
return ERR_NO_ERROR;
|
|
}
|
|
|
|
// open art files until we find one that encompasses the range we need
|
|
// and when we find it, make the change
|
|
for (filenum = 0; filenum < 1000; filenum++) {
|
|
ARTFile art(makefilename(filenum));
|
|
|
|
if (art.getNumTiles() == 0) {
|
|
// no file exists, so give up
|
|
break;
|
|
}
|
|
|
|
if (tilenum_ >= art.getFirstTile() && tilenum_ <= art.getLastTile()) {
|
|
if (settings_ & SET_XOFS) {
|
|
art.setXOfs(tilenum_, xofs_);
|
|
}
|
|
if (settings_ & SET_YOFS) {
|
|
art.setYOfs(tilenum_, yofs_);
|
|
}
|
|
if (settings_ & SET_ANIMFRAMES) {
|
|
art.setAnimFrames(tilenum_, animframes_);
|
|
}
|
|
if (settings_ & SET_ANIMSPEED) {
|
|
art.setAnimSpeed(tilenum_, animspeed_);
|
|
}
|
|
if (settings_ & SET_ANIMTYPE) {
|
|
art.setAnimType(tilenum_, animtype_);
|
|
}
|
|
art.write();
|
|
return ERR_NO_ERROR;
|
|
}
|
|
}
|
|
|
|
return ERR_NO_ART_FILE;
|
|
}
|
|
};
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
int showusage = 0;
|
|
Operation * oper = 0;
|
|
Operation::Result err = Operation::ERR_NO_ERROR;
|
|
|
|
if (argc < 2) {
|
|
showusage = 1;
|
|
} else {
|
|
string opt(argv[1]);
|
|
string value;
|
|
|
|
// create the option handler object according to the first param
|
|
if (opt == "create") {
|
|
oper = new CreateOp;
|
|
} else if (opt == "addtile") {
|
|
oper = new AddTileOp;
|
|
} else if (opt == "rmtile") {
|
|
oper = new RmTileOp;
|
|
} else if (opt == "tileprop") {
|
|
oper = new TilePropOp;
|
|
} else {
|
|
showusage = 2;
|
|
}
|
|
|
|
// apply the command line options given
|
|
if (oper) {
|
|
int unnamedParm = 0;
|
|
for (int i = 2; i < argc && !showusage; i++) {
|
|
if (argv[i][0] == '-') {
|
|
opt = string(argv[i]).substr(1);
|
|
if (i+1 >= argc) {
|
|
showusage = 2;
|
|
break;
|
|
}
|
|
value = string(argv[i+1]);
|
|
i++;
|
|
|
|
switch (err = oper->setOption(opt, value)) {
|
|
case Operation::ERR_NO_ERROR: break;
|
|
default:
|
|
cerr << "error: " << Operation::translateResult(err) << endl;
|
|
showusage = 2;
|
|
break;
|
|
}
|
|
} else {
|
|
value = string(argv[i]);
|
|
switch (oper->setParameter(unnamedParm, value)) {
|
|
case Operation::ERR_NO_ERROR: break;
|
|
default:
|
|
cerr << "error: " << Operation::translateResult(err) << endl;
|
|
showusage = 2;
|
|
break;
|
|
}
|
|
unnamedParm++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showusage) {
|
|
usage();
|
|
if (oper) delete oper;
|
|
return (showusage - 1);
|
|
} else if (oper) {
|
|
err = oper->perform();
|
|
delete oper;
|
|
|
|
switch (err) {
|
|
case Operation::ERR_NO_ERROR: return 0;
|
|
default:
|
|
cerr << "error: " << Operation::translateResult(err) << endl;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|