scummvm/engines/saga2/spellio.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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
 * aint32 with this program; if not, write to the Free Software
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#include "saga2/saga2.h"
#include "saga2/idtypes.h"
#include "saga2/magic.h"
#include "saga2/effects.h"
#include "saga2/spellbuk.h"
#include "saga2/tcoords.h"
#include "saga2/rect.h"
#include "saga2/spellio.h"
#include "saga2/spelshow.h"
#include "saga2/saveload.h"

namespace Saga2 {

/* ===================================================================== *
   partial SpellDisplayPrototype implementation
 * ===================================================================== */

// ------------------------------------------------------------------
// ctor

SpellDisplayPrototype::SpellDisplayPrototype(ResourceSpellItem *rsi) {
	_effect = rsi->effect;                // Effect ID
	_effParm1 = 0;                        //   effect setting 1
	_effParm2 = 0;                        //   effect setting 1
	_effParm3 = 0;                        //   effect setting 1
	_effParm4 = 0;                        //   effect setting 1
	_scatter = kDiFlagZero;                // direction init mode
	_elasticity = (effectCollisionCont) rsi->effectronElasticity; // collision flags
	_maxAge = rsi->maxAge;                // auto self-destruct age
	_implementAge = rsi->implAge;         // auto self-destruct age
	_primarySpriteID = rsi->baseSprite; // RES_ID(x, y, z, 0) to get sprites
	_primarySpriteNo = rsi->spriteCount; // sprites available
	_secondarySpriteID = rsi->baseSprite2; // RES_ID(x, y, z, 0) to get sprites
	_secondarySpriteNo = rsi->spriteCount2; // sprites available
	//_effCount=0;            // effectrons to allocate
	_colorMap[0] = rsi->cm0;
	_colorMap[1] = rsi->cm1;
	_colorMap[2] = 0;
	_colorMap[3] = 0;
	_ID = kSpellNone;
}

/* ===================================================================== *
   partial SpellStuff implementation
 * ===================================================================== */

// ------------------------------------------------------------------
// init from res file

void SpellStuff::setupFromResource(ResourceSpellItem *rsi) {
	_master = (SpellID) rsi->spell;
	_display = (SpellID) rsi->spell;
	_targetableTypes = (SpellTargetingTypes) rsi->targs;
	_targetTypes = (SpellApplicationTypes) rsi->applys;
	_manaType = (SpellManaID) rsi->manaType;
	_manaUse = rsi->manaAmount;
	_shape = (effectAreas) rsi->effect;
	_size = 0;
	_sound = rsi->soundID;
}

// ------------------------------------------------------------------
// add spell internal effect

void SpellStuff::addEffect(ResourceSpellEffect *rse) {
	ProtoEffect *pe = nullptr;
	assert(rse && rse->spell == _master);
	switch (rse->effectGroup) {
	case kEffectNone     :
		return;
	case kEffectAttrib   :
		pe = new ProtoEnchantment(
		         makeEnchantmentID(
		             rse->effectGroup,
		             rse->effectType,
		             rse->attribModifier),
		         rse->enchTimeLo,
		         rse->enchTimeHi);
		break;
	case kEffectResist   :
	case kEffectImmune   :
	case kEffectOthers   :
	case kEffectNonActor :
		pe = new ProtoEnchantment(
		         makeEnchantmentID(
		             rse->effectGroup,
		             rse->effectType,
		             rse->flagSet),
		         rse->enchTimeLo,
		         rse->enchTimeHi);
		break;
	case kEffectDamage   :
		pe = new ProtoDamage(
		         rse->baseDice,
		         rse->diceSides ? rse->diceSides : 6,
		         rse->skillDice,
		         0,
		         (effectDamageTypes) rse->effectType,
		         0,
		         rse->targeting & kSpellTargCaster);
		break;
	case kEffectDrains   :
		pe = new ProtoDrainage(
		         rse->baseDice,
		         rse->diceSides ? rse->diceSides : 6,
		         rse->skillDice,
		         0,
		         (effectDrainsTypes) rse->effectType,
		         0,
		         rse->targeting & kSpellTargCaster);
		break;
	case kEffectTAG      :
		pe = new ProtoTAGEffect(
		         (effectTAGTypes) rse->effectType,
		         rse->flagSet,
		         rse->attribModifier);
		break;
	case kEffectLocation :
		pe = new ProtoLocationEffect(
		         (kEffectLocationTypes) rse->effectType,
		         rse->attribModifier);
		break;
	case kEffectSpecial  : {
		switch (rse->effectType) {
		case    kSpecialDispellHelpfulEnch :   // clears helpful enchantments
			pe = new ProtoSpecialEffect(DispellProtections, rse->attribModifier);
			break;
		case    kSpecialDispellHarmfulEnch :   // clears harmful enchantments
			pe = new ProtoSpecialEffect(DispellCurses,      rse->attribModifier);
			break;
		case    kSpecialKill               :   // death spell
			pe = new ProtoSpecialEffect(DeathSpell,         rse->attribModifier);
			break;
		case    kSpecialRessurect          :   // raise dead spell
			pe = new ProtoSpecialEffect(Resurrect,          rse->attribModifier);
			break;
		case    kSpecialTeleport           :   // Teleportation
			pe = new ProtoSpecialEffect(TeleportToLocation, rse->attribModifier);
			break;
		case    kSpecialCreateActor        :   // Create an actor or wall
			pe = new ProtoSpecialEffect(CreateWraith,       rse->attribModifier);
			break;
		case    kSpecialSagaFunc           :    // calls a saga function
			pe = new ProtoSpecialEffect(SagaSpellCall,      rse->attribModifier);
			break;
		case    kSpecialRejoin        :   // Create an actor or wall
			pe = new ProtoSpecialEffect(Rejoin,      rse->attribModifier);
			break;
		case    kSpecialCreateWWisp  :  // calls a saga function
			pe = new ProtoSpecialEffect(CreateWWisp,      rse->attribModifier);
			break;
		case    kSpecialCreateFWisp  :   // calls a saga function
			pe = new ProtoSpecialEffect(CreateFWisp,      rse->attribModifier);
			break;
		case    kSpecialCreateWraith :   // calls a saga function
			pe = new ProtoSpecialEffect(CreateWraith,      rse->attribModifier);
			break;
		case    kSpecialCreateFood   :   // calls a saga function
			pe = new ProtoSpecialEffect(CreateFood,      rse->attribModifier);
			break;
		}
		break;
	}
	}
	if (pe == nullptr)
		error("failed to alloc protoEffect");

	if (_effects == nullptr)
		_effects = pe;
	else {
		ProtoEffect *tail;
		for (tail = _effects; tail->_next; tail = tail->_next) ;
		tail->_next = pe;
	}
}

// ------------------------------------------------------------------
// init spells

void initSpellState() {
}

void saveSpellState(Common::OutSaveFile *outS) {
	debugC(2, kDebugSaveload, "Saving SpellState");
	g_vm->_activeSpells->write(outS);
}

void loadSpellState(Common::InSaveFile *in) {
	debugC(2, kDebugSaveload, "Loading SpellState");

	g_vm->_activeSpells->read(in);
}

// ------------------------------------------------------------------
// cleanup active spells

void cleanupSpellState() {
	g_vm->_activeSpells->wipe();
}

// ------------------------------------------------------------------
// cleanup active _spells

StorageSpellTarget::StorageSpellTarget(SpellTarget &st) {
	GameObject *go = nullptr;
	ActiveItem *ai;
	type = st.getType();
	loc = st.getPoint();
	if (type == SpellTarget::kSpellTargetObject) {
		if (type == SpellTarget::kSpellTargetObject)
			go = st.getObject();
		else
			go = nullptr;
	}

	if (go)
		obj = go->thisID();
	else
		obj = Nothing;

	if (type == SpellTarget::kSpellTargetTAG)
		ai = st.getTAG();
	else
		ai = nullptr;

	if (ai)
		tag = ai->thisID();
	else
		tag = NoActiveItem;
}

StorageSpellInstance::StorageSpellInstance(SpellInstance &si) {
	implementAge = si._implementAge; // age at which to implement the spell effects
	effect = si._effect->thisID();      // effect prototype of the current effect
	dProto = si._dProto->thisID();      // effect prototype of the current effect
	caster = si._caster->thisID();
	target = StorageSpellTarget(*si._target);
	world = si._world->thisID();
	age = si._age;
	spell = si._spell;
	maxAge = si._maxAge;
	effSeq = si._effSeq;         // which effect in a sequence is being played
	eListSize = si._eList._count;
}

StorageSpellTarget::StorageSpellTarget() {
	type = 0;
	loc = Nowhere;
	obj = Nothing;
	tag = NoActiveItem;
}

void StorageSpellTarget::read(Common::InSaveFile *in) {
	ActiveItemID tagID;

	type = in->readSint16LE();
	loc.load(in);
	obj = in->readUint16LE();
	tagID = in->readSint16LE();
	tag = ActiveItemID(tagID);
}

void StorageSpellTarget::write(Common::MemoryWriteStreamDynamic *out) {
	out->writeSint16LE(type);
	loc.write(out);
	out->writeUint16LE(obj);
	out->writeSint16LE(tag.val);
}

StorageSpellInstance::StorageSpellInstance() : implementAge(0), effect(0), dProto(kSpellNone), caster(0),
	world(0), age(0), spell(kSpellNone), maxAge(0), effSeq(0), eListSize(0) {
}

void StorageSpellInstance::read(Common::InSaveFile *in) {
	implementAge = in->readSint32LE();
	effect = in->readUint16LE();
	dProto = (SpellID)in->readByte();
	caster = in->readUint16LE();
	target.read(in);
	world = in->readUint16LE();
	age = in->readSint32LE();
	spell = (SpellID)in->readByte();
	maxAge = in->readSint32LE();
	effSeq = in->readSint16LE();
	eListSize = in->readSint16LE();
}

void StorageSpellInstance::write(Common::MemoryWriteStreamDynamic *out) {
	out->writeSint32LE(implementAge);
	out->writeUint16LE(effect);
	out->writeByte(dProto);
	out->writeUint16LE(caster);
	target.write(out);
	out->writeUint16LE(world);
	out->writeSint32LE(age);
	out->writeByte(spell);
	out->writeSint32LE(maxAge);
	out->writeSint16LE(effSeq);
	out->writeSint16LE(eListSize);
}

SpellTarget::SpellTarget(StorageSpellTarget &sst) {
	_type = (SpellTarget::spellTargetType) sst.type;
	_loc = sst.loc;
	_next = nullptr;
	if (sst.obj != Nothing)
		_obj = GameObject::objectAddress(sst.obj);
	else
		_obj = nullptr;
	if (sst.tag != NoActiveItem)
		_tag = ActiveItem::activeItemAddress(sst.tag);
	else
		_tag = nullptr;
}

SpellInstance::SpellInstance(StorageSpellInstance &ssi) {
	_implementAge = ssi.implementAge; // age at which to implement the spell effects
	_dProto = (*g_vm->_sdpList)[ssi.dProto];
	_caster = GameObject::objectAddress(ssi.caster);
	_target = new SpellTarget(ssi.target);
	GameObject *go = GameObject::objectAddress(ssi.world);
	assert(isWorld(go));
	_world = (GameWorld *) go;
	_age = ssi.age;
	_spell = ssi.spell;
	_maxAge = ssi.maxAge;
	_effSeq = 0;
	_effect = (*g_vm->_edpList)[ssi.effect];
	while (_effSeq < ssi.effSeq)         // which effect in a sequence is being played
		_effect = _effect->_next;
}

size_t SpellDisplayList::saveSize() {
	size_t total = 0;

	total += sizeof(_count);
	if (_count) {
		for (int i = 0; i < _count; i++)
			total += _spells[i]->saveSize();
	}
	return total;
}

void SpellDisplayList::write(Common::OutSaveFile *outS) {
	outS->write("SPEL", 4);
	CHUNK_BEGIN;
	out->writeUint16LE(_count);

	debugC(3, kDebugSaveload, "... count = %d", _count);

	if (_count) {
		for (int i = 0; i < _count; i++) {
			debugC(3, kDebugSaveload, "Saving Spell Instance %d", i);
			StorageSpellInstance ssi = StorageSpellInstance(*_spells[i]);
			ssi.write(out);
			_spells[i]->writeEffect(out);
		}
	}
	CHUNK_END;
}

void SpellDisplayList::read(Common::InSaveFile *in) {
	uint16 tCount;

	tCount = in->readUint16LE();

	debugC(3, kDebugSaveload, "... count = %d", tCount);

	assert(tCount < _maxCount);
	if (tCount) {
		for (int i = 0; i < tCount; i++) {
			debugC(3, kDebugSaveload, "Loading Spell Instance %d", i);
			SpellInstance *si;
			StorageSpellInstance ssi;
			ssi.read(in);
			si = new SpellInstance(ssi);
			add(si);
			si->readEffect(in, ssi.eListSize);
		}
	}
	assert(tCount == _count);
}

void SpellDisplayList::wipe() {
	for (int i = 0; i < _maxCount; i++)
		if (_spells[i]) {
			delete _spells[i];
			_spells[i] = nullptr;
			_count--;
		}

	assert(_count == 0);
}

size_t SpellInstance::saveSize() {
	size_t total = 0;
	total += sizeof(StorageSpellInstance);
	if (_eList._count)
		for (int32 i = 0; i < _eList._count; i++) {
			total += sizeof(StorageEffectron);
		}
	return total;
}

void SpellInstance::writeEffect(Common::MemoryWriteStreamDynamic *out) {
	if (_eList._count > 0 && !(_maxAge > 0 && (_age + 1) > _maxAge))
		for (int32 i = 0; i < _eList._count; i++) {
			StorageEffectron se = StorageEffectron(*_eList._displayList[i]._efx);
			se.write(out);
		}
}

void SpellInstance::readEffect(Common::InSaveFile *in, uint16 eListSize) {
	assert(eListSize == _effect->_nodeCount);
	_eList._count = _effect->_nodeCount; //sdp->effCount;
	if (_eList._count)
		for (int32 i = 0; i < _eList._count; i++) {
			StorageEffectron se;
			se.read(in);
			Effectron *e = new Effectron(se, this);
			_eList._displayList[i]._efx = e;
		}
}

StorageEffectron::StorageEffectron() {
	flags = 0;
	size = Extent16(0, 0);
	hitBox = Rect16(0, 0, 0, 0);
	screenCoords = Point16(0, 0);
	partno = 0;
	start = Nowhere;
	finish = Nowhere;
	current = Nowhere;
	velocity = TilePoint(0, 0, 0);
	acceleration = TilePoint(0, 0, 0);
	totalSteps = 0;
	stepNo = 0;
	hgt = 0;
	brd = 0;
	pos = 0;
	spr = 0;
	age = 0;
}

StorageEffectron::StorageEffectron(Effectron &e) {
	flags =         e._flags;
	size =          e._size;
	hitBox =        e._hitBox;
	screenCoords =  e._screenCoords;
	partno =        e._partno;
	start =         e._start;
	finish =        e._finish;
	current =       e._current;
	velocity =      e._velocity;
	acceleration =  e._acceleration;
	totalSteps =    e._totalSteps;
	stepNo =        e._stepNo;
	hgt =           e._hgt;
	brd =           e._brd;
	pos =           e._pos;
	spr =           e._spr;
	age =           e._age;
}

void StorageEffectron::read(Common::InSaveFile *in) {
	flags = in->readUint32LE();
	size.load(in);
	hitBox.read(in);
	partno = in->readSint16LE();
	screenCoords.load(in);
	start.load(in);
	finish.load(in);
	current.load(in);
	velocity.load(in);
	acceleration.load(in);
	totalSteps = in->readUint16LE();
	stepNo = in->readUint16LE();
	hgt = in->readSint16LE();
	brd = in->readSint16LE();
	pos = in->readSint32LE();
	spr = in->readSint32LE();
	age = in->readSint32LE();
}

void StorageEffectron::write(Common::MemoryWriteStreamDynamic *out) {
	out->writeUint32LE(flags);
	size.write(out);
	hitBox.write(out);
	out->writeSint16LE(partno);
	screenCoords.write(out);
	start.write(out);
	finish.write(out);
	current.write(out);
	velocity.write(out);
	acceleration.write(out);
	out->writeUint16LE(totalSteps);
	out->writeUint16LE(stepNo);
	out->writeSint16LE(hgt);
	out->writeSint16LE(brd);
	out->writeSint32LE(pos);
	out->writeSint32LE(spr);
	out->writeSint32LE(age);
}

Effectron::Effectron(StorageEffectron &se, SpellInstance *si) {
	_flags =         se.flags;
	_size =          se.size;
	_hitBox =        se.hitBox;
	_screenCoords =  se.screenCoords;
	_partno =        se.partno;
	_start =         se.start;
	_finish =        se.finish;
	_current =       se.current;
	_velocity =      se.velocity;
	_acceleration =  se.acceleration;
	_totalSteps =    se.totalSteps;
	_stepNo =        se.stepNo;
	_hgt =           se.hgt;
	_brd =           se.brd;
	_pos =           se.pos;
	_spr =           se.spr;
	_age =           se.age;
	_parent = si;
}

} // end of namespace Saga2