FieldPS.cpp

/****************************************************************************
 ** Deling Final Fantasy VIII Field Editor
 ** Copyright (C) 2009-2012 Arzel Jérôme <myst6re@gmail.com>
 **
 ** This program is free software: you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation, either version 3 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** You should have received a copy of the GNU General Public License
 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
#include "FieldPS.h"

FieldDatHeader::FieldDatHeader(const QByteArray &dat)
{
	memcpy(posSections, dat.constData(), 48);// 12 * 4

	memoryPos = posSections[Inf] - 48;

	for(int i=Inf ; i<=Last ; ++i)
		posSections[i] -= memoryPos;
}

bool FieldDatHeader::isValid(int datSize) const
{
	if((int)posSections[Last] != datSize) {
		return false;
	}

	for(int i=Inf ; i<Last ; ++i) {
		if(posSections[i] > posSections[i+1]) {
			return false;
		}
	}

	return true;
}

quint32 FieldDatHeader::position(DatSections section) const
{
	return posSections[section];
}

quint32 FieldDatHeader::size(DatSections section) const
{
	if(section == Last) {
		return 0;
	}

	return posSections[section+1] - posSections[section];
}

void FieldDatHeader::setSize(DatSections section, quint32 newSize)
{
	if(section == Last) {
		return;
	}

	int diff = newSize - size(section);

	for(int i=section+1 ; i<=Last ; ++i) {
		posSections[i] += diff;
	}
}

QByteArray FieldDatHeader::save() const
{
	QByteArray header;

	for(int i=Inf ; i<=Last ; ++i) {
		quint32 posSection = posSections[i] + memoryPos;
		header.append((char *)&posSection, 4);
	}

	return header;
}

FieldPS::FieldPS(const QByteArray &dat, quint32 isoFieldID)
	: Field(QString()), _isoFieldID(isoFieldID)
{
	open(dat);
}

FieldPS::~FieldPS()
{
}

bool FieldPS::isPc() const
{
	return false;
}

bool FieldPS::hasFiles2() const
{
	return true;
}

//void FieldPS::setIsoFieldID(quint32 isoFieldID)
//{
//	this->isoFieldID = isoFieldID;
//}

quint32 FieldPS::isoFieldID() const
{
	return _isoFieldID;
}

bool FieldPS::open(const QByteArray &dat)
{
	setOpen(false);
	// pvp + mim + tdw + pmp (MIM)
	// inf + ca + id + map + msk + rat + mrt + AKAO + msd + pmd + jsm (DAT)
	FieldDatHeader header(dat);

	if(!header.isValid(dat.size())) {
		qWarning() << "Bad dat header" << dat.size();
		return false;
	}

	setName(dat.mid(48, 8));

	/* INF */
	openFile(Field::Inf, dat.mid(header.position(FieldDatHeader::Inf), header.size(FieldDatHeader::Inf)));

	/* CA */
	openFile(Field::Ca, dat.mid(header.position(FieldDatHeader::Ca), header.size(FieldDatHeader::Ca)));

	/* ID */
	openFile(Field::Id, dat.mid(header.position(FieldDatHeader::Id), header.size(FieldDatHeader::Id)));

	/* MSK */
	openFile(Field::Msk, dat.mid(header.position(FieldDatHeader::Msk), header.size(FieldDatHeader::Msk)));

	/* RAT */
	openFile(Field::Rat, dat.mid(header.position(FieldDatHeader::Rat), header.size(FieldDatHeader::Rat)));

	/* MRT */
	openFile(Field::Mrt, dat.mid(header.position(FieldDatHeader::Mrt), header.size(FieldDatHeader::Mrt)));

	/* AKAO */
	openFile(Field::AkaoList, dat.mid(header.position(FieldDatHeader::AKAO), header.size(FieldDatHeader::AKAO)));

	/* MSD */
	openFile(Field::Msd, dat.mid(header.position(FieldDatHeader::Msd), header.size(FieldDatHeader::Msd)));

	/* PMD */
	openFile(Field::Pmd, dat.mid(header.position(FieldDatHeader::Pmd), header.size(FieldDatHeader::Pmd)));

	/* JSM */
	openJsmFile(dat.mid(header.position(FieldDatHeader::Jsm), header.size(FieldDatHeader::Jsm)));

	setOpen(true);
	return true;
}

bool FieldPS::open2(const QByteArray &dat, const QByteArray &mim, const QByteArray &lzk)
{
	const char *constData = mim.constData();

	quint32 posSectionPvp = 8, posSectionMim = posSectionPvp + 4;

	if(!hasTdwFile()) {
		quint32 posSectionTdwRam, posSectionTdw, posSectionPmpRam, posSectionPmp;

		memcpy(&posSectionTdwRam, constData, 4);
		memcpy(&posSectionPmpRam, &constData[4], 4);
		posSectionTdw = posSectionMim + 438272;
		posSectionPmp = posSectionPmpRam * posSectionTdw / posSectionTdwRam;

		/* PVP */
		openFile(Field::Pvp, mim.mid(posSectionPvp, posSectionMim-posSectionPvp));
		/* TDW */
		openFile(Field::Tdw, mim.mid(posSectionTdw, posSectionPmpRam-posSectionTdwRam));
		/* PMP */
		openFile(Field::Pmp, mim.mid(posSectionPmp));
	}

	constData = dat.constData();
	quint32 posSectionInf, posSectionMap, posSectionMsk, memoryPos;

	memcpy(&posSectionInf, constData, 4);
	memcpy(&posSectionMap, &constData[12], 4);
	memcpy(&posSectionMsk, &constData[16], 4);

	memoryPos = posSectionInf - 48;

	openBackgroundFile(dat.mid(posSectionMap - memoryPos, posSectionMsk-posSectionMap), mim.mid(posSectionMim, 438272));

	openCharaFile(lzk);

	return true;
}

bool FieldPS::save(QByteArray &dat, QByteArray &mim)
{
	// pvp + mim + tdw + pmp (MIM)
	// inf + ca + id + map + msk + rat + mrt + AKAO + msd + pmd + jsm (DAT)
	FieldDatHeader header(dat);

	if(hasMsdFile() && getMsdFile()->isModified()) {
		QByteArray msd;
		if(getMsdFile()->save(msd)) {
			dat.replace(header.position(FieldDatHeader::Msd), header.size(FieldDatHeader::Msd), msd);
			header.setSize(FieldDatHeader::Msd, msd.size());
		}
	}
	if(hasJsmFile() && getJsmFile()->isModified()) {
		QByteArray sym, jsm;
		if(getJsmFile()->save(jsm, sym)) {
			dat.replace(header.position(FieldDatHeader::Jsm), header.size(FieldDatHeader::Jsm), jsm);
			header.setSize(FieldDatHeader::Jsm, jsm.size());
		}
	}
	if(hasRatFile() && getRatFile()->isModified()) {
		QByteArray rat;
		if(getRatFile()->save(rat)) {
			dat.replace(header.position(FieldDatHeader::Rat), header.size(FieldDatHeader::Rat), rat);
			header.setSize(FieldDatHeader::Rat, rat.size());
		}
	}
	if(hasMrtFile() && getMrtFile()->isModified()) {
		QByteArray mrt;
		if(getMrtFile()->save(mrt)) {
			dat.replace(header.position(FieldDatHeader::Mrt), header.size(FieldDatHeader::Mrt), mrt);
			header.setSize(FieldDatHeader::Mrt, mrt.size());
		}
	}
	if(hasInfFile() && getInfFile()->isModified()) {
		QByteArray inf;
		if(getInfFile()->save(inf)) {
			dat.replace(header.position(FieldDatHeader::Inf), header.size(FieldDatHeader::Inf), inf);
			header.setSize(FieldDatHeader::Inf, inf.size());
		}
	}
	if(hasPmpFile() && getPmpFile()->isModified()) {
		QByteArray pmp;
		if(getPmpFile()->save(pmp)) {
			// TODO: pmp
		}
	}
	if(hasPmdFile() && getPmdFile()->isModified()) {
		QByteArray pmd;
		if(getPmdFile()->save(pmd)) {
			dat.replace(header.position(FieldDatHeader::Pmd), header.size(FieldDatHeader::Pmd), pmd);
			header.setSize(FieldDatHeader::Pmd, pmd.size());
		}
	}
	if(hasPvpFile() && getPvpFile()->isModified()) {
		QByteArray pvp;
		if(getPvpFile()->save(pvp)) {
			mim.replace(8, 4, pvp);
		}
	}
	if(hasIdFile() && getIdFile()->isModified()) {
		QByteArray id;
		if(getIdFile()->save(id)) {
			dat.replace(header.position(FieldDatHeader::Id), header.size(FieldDatHeader::Id), id);
			header.setSize(FieldDatHeader::Id, id.size());
		}
	}
	if(hasCaFile() && getCaFile()->isModified()) {
		QByteArray ca;
		if(getCaFile()->save(ca)) {
			dat.replace(header.position(FieldDatHeader::Ca), header.size(FieldDatHeader::Ca), ca);
			header.setSize(FieldDatHeader::Ca, ca.size());
		}
	}
	if(hasMskFile() && getMskFile()->isModified()) {
		QByteArray msk;
		if(getMskFile()->save(msk)) {
			dat.replace(header.position(FieldDatHeader::Msk), header.size(FieldDatHeader::Msk), msk);
			header.setSize(FieldDatHeader::Msk, msk.size());
		}
	}
	if(hasTdwFile() && getTdwFile()->isModified()) {
		QByteArray tdw;
		if(getTdwFile()->save(tdw)) {
			//TODO: tdw
		}
	}
	if(hasAkaoListFile() && getAkaoListFile()->isModified()) {
		QByteArray akao;
		if(getAkaoListFile()->save(akao)) {
			dat.replace(header.position(FieldDatHeader::AKAO), header.size(FieldDatHeader::AKAO), akao);
			header.setSize(FieldDatHeader::AKAO, akao.size());
		}
	}

	dat.replace(0, 48, header.save());

	return true;
}