blame: source/code/replay.cpp

/*

===========================================================================

blockattack - Block Attack - Rise of the Blocks

Copyright (C) 2005-2012 Poul Sander

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 2 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/

Source information and contacts persons can be found at

http://blockattack.sf.net

===========================================================================

*/

/*

Handles replay

*/

#include <string.h>

#include "replay.h"

Replay::Replay()

{

	nrOfFrames=0;

	isLoaded = false;

}

Replay::Replay(const Replay& r)

{

	bps = r.bps;

	finalPack = r.finalPack;

	nrOfFrames = r.nrOfFrames;

	isLoaded = r.isLoaded;

	theResult = r.theResult;

	strncpy(name,r.name,sizeof(name));

	actions = r.actions;

}

Uint32 Replay::getNumberOfFrames()

{

	return nrOfFrames;

}

void Replay::setFrameSecTo(Uint32 miliseconds, boardPackage bp)

{

	if (isLoaded)

		return;

	int framesToSet = (miliseconds*FRAMESPERSEC)/1000;

	for (int i=nrOfFrames; i<framesToSet; i++)

	{

		bps.push_back(bp);

	}

	nrOfFrames=framesToSet;

}

void Replay::setFinalFrame(boardPackage bp,int theStatus)

{

	if (isLoaded)

		return;

	finalPack = bp;

	switch (theStatus)

	{

	case 1:

		theResult = winner;

		break;

	case 2:

		theResult = looser;

		break;

	case 3:

		theResult = draw;

		break;

	default:

		theResult = gameOver;

	};

}

//Returns the frame to the current time, if time too high the final frame is returned

boardPackage Replay::getFrameSec(Uint32 miliseconds)

{

	int frameToGet = (miliseconds*FRAMESPERSEC)/1000;

	if (!(frameToGet<nrOfFrames))

		return getFinalFrame();

	return bps.at(frameToGet);

}

bool Replay::isFinnished(Uint32 miliseconds)

{

	int frameToGet = (miliseconds*FRAMESPERSEC)/1000;

	if (!(frameToGet<nrOfFrames))

		return true;

	return false;

}

boardPackage Replay::getFinalFrame()

{

	return finalPack;

}

int Replay::getFinalStatus()

{

	return theResult;

}

bool Replay::saveReplay(string filename)

{

	//Saving as fileversion 4

	cout << "Saving as version 4 save file" << endl;

	ofstream saveFile;

	saveFile.open(filename.c_str(),ios::binary|ios::trunc);

	if (saveFile)

	{

		saveFile << "0 PLAYER 1\n";

		saveFile << "0 NAME " << name << "\n";

		for(int i = 0;i < actions.size(); ++i) {

			saveFile << actions.at(i).time << " " << actions.at(i).action << "\n";

		}

		saveFile.close();

		return true;

	}

	else

	{

		return false;

	}

}

bool Replay::saveReplay(string filename,Replay p2)

{

	//Saving as fileversion 3

	cout << "Saving as version 3 save file (2 players)" << endl;

	ofstream saveFile;

	saveFile.open(filename.c_str(),ios::binary|ios::trunc);

	if (saveFile)

	{

		Uint32 version = 4;

		boardPackage bp;

		saveFile.write(reinterpret_cast<char*>(&version),sizeof(Uint32)); //Fileversion

		Uint8 nrOfReplays = 2;

		saveFile.write(reinterpret_cast<char*>(&nrOfReplays),sizeof(Uint8)); //nrOfReplaysIn File

		saveFile.write(reinterpret_cast<char*>(&nrOfFrames),sizeof(Uint32)); //Nr of frames in file

		for (int i=0; i<nrOfFrames && i<bps.size(); i++)

		{

			//Writing frames

			bp = bps.at(i);

			saveFile.write(reinterpret_cast<char*>(&bp),sizeof(bp));

		}

		saveFile.write(reinterpret_cast<char*>(&finalPack),sizeof(finalPack));

		saveFile.write(reinterpret_cast<char*>(&theResult),sizeof(theResult));

		saveFile.write(reinterpret_cast<char*>(&name),sizeof(name));

		///Player 2 starts here!!!!!!!!!!!!!!!!!!!!!!

		saveFile.write(reinterpret_cast<char*>(&p2.nrOfFrames),sizeof(Uint32)); //Nr of frames in file

		for (int i=0; (i<p2.nrOfFrames)&& i<p2.bps.size(); i++)

		{

			//Writing frames

			bp = p2.bps.at(i);

			saveFile.write(reinterpret_cast<char*>(&bp),sizeof(bp));

		}

		saveFile.write(reinterpret_cast<char*>(&p2.finalPack),sizeof(finalPack));

		saveFile.write(reinterpret_cast<char*>(&p2.theResult),sizeof(theResult));

		saveFile.write(reinterpret_cast<char*>(&p2.name),sizeof(name));

		saveFile.close();

		return true;

	}

	else

	{

		return false;

	}

}

bool Replay::loadReplay(string filename)

{

	isLoaded = true;

	ifstream loadFile;

	loadFile.open(filename.c_str(),ios::binary);

	if (loadFile)

	{

		Uint32 version;

		loadFile.read(reinterpret_cast<char*>(&version),sizeof(Uint32));

		switch (version)

		{

		case 3:

			cout << "Loading a version 3 save game" << endl;

			Uint8 nrOfPlayers;

			boardPackage bp;

			loadFile.read(reinterpret_cast<char*>(&nrOfPlayers),sizeof(Uint8));

			loadFile.read(reinterpret_cast<char*>(&nrOfFrames),sizeof(Uint32));

			bps.clear();

			for (int i=0; (i<nrOfFrames); i++)

			{

				loadFile.read(reinterpret_cast<char*>(&bp),sizeof(bp));

				bps.push_back(bp);

			}

			loadFile.read(reinterpret_cast<char*>(&finalPack),sizeof(finalPack));

			loadFile.read(reinterpret_cast<char*>(&theResult),sizeof(theResult));

			loadFile.read(reinterpret_cast<char*>(&name),sizeof(name));

			break;

		default:

			cout << "Unknown version" << endl;

			return false;

		};

		loadFile.close();

		cout << "Loaded 1 player" << endl;

	}

	else

	{

		cout << "File not found or couldn't open: " << filename << endl;

		return false;

	}

}

bool Replay::loadReplay2(string filename)

{

	isLoaded = true;

	ifstream loadFile;

	loadFile.open(filename.c_str(),ios::binary);

	if (loadFile)

	{

		Uint32 version;

		loadFile.read(reinterpret_cast<char*>(&version),sizeof(Uint32));

		switch (version)

		{

		case 3:

			Uint8 nrOfPlayers;

			boardPackage bp;

			loadFile.read(reinterpret_cast<char*>(&nrOfPlayers),sizeof(Uint8));

			if (nrOfPlayers<2)

			{

				loadFile.close();

				cout << "Only one player in replay" << endl;

				return false;

			}

			cout << "loading player 2" << endl;

			loadFile.read(reinterpret_cast<char*>(&nrOfFrames),sizeof(Uint32));

			for (int i=0; (i<nrOfFrames); i++)

			{

				loadFile.read(reinterpret_cast<char*>(&bp),sizeof(bp));

				//bps.push_back(bp); We have already read player 1 with another function

			}

			loadFile.read(reinterpret_cast<char*>(&finalPack),sizeof(finalPack));

			loadFile.read(reinterpret_cast<char*>(&theResult),sizeof(theResult));

			loadFile.read(reinterpret_cast<char*>(&name),sizeof(name));

			loadFile.read(reinterpret_cast<char*>(&nrOfFrames),sizeof(Uint32));

			bps.reserve(nrOfFrames);

			for (int i=0; (i<nrOfFrames); i++)

			{

				loadFile.read(reinterpret_cast<char*>(&bp),sizeof(bp));

				bps.push_back(bp);

			}

			loadFile.read(reinterpret_cast<char*>(&finalPack),sizeof(finalPack));

			loadFile.read(reinterpret_cast<char*>(&theResult),sizeof(theResult));

			loadFile.read(reinterpret_cast<char*>(&name),sizeof(name));

			break;

		default:

			cout << "Unknown version: " << version << endl;

			return false;

		};

		loadFile.close();

	}

	else

	{

		cout << "File not found or couldn't open: " << filename << endl;

		return false;

	}

}

void Replay::addAction(int tick, string action) {

	cout << tick << " " << action << endl;

	Action a;

	a.time = tick;

	a.action = action;

	actions.push_back(a);

}