~proyvind/doonlunacy/od2

/* OD2 - Dune II Clone
 *  
 * Copyright (C) 2009 Robert Crossfield		<robert.crossfield@strobs.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/>.
 *  
 * 
 * $Id$
 * 
 */

#include "stdafx.h"
#include "od2.h"
#include "engine/house.h"
#include "engine/objects/object.h"
#include "engine/objects/unit.h"
#include "engine/objects/structure.h"
#include "engine/script/scriptEmc.h"
#include "engine/script/scriptEmcUnit.h"
#include "engine/script/scriptEmcStructure.h"

#include<iostream>

cDebug::cDebug( cOD2 *pEngine ) : cBase< cOD2 >( pEngine ) {
	_break = false;

	commandSetup();

	if(pEngine->debugLevelGet() > 0) {

		engineGet()->gameImmediateBuild( true );
		engineGet()->gameFreeBuild( true );
	}


}

cDebug::~cDebug() {

}

string cDebug::dumpStack( cScriptData *pScriptData ) {
	stringstream tmp;

	return tmp.str();
}


string cDebug::dumpRegisters( cScriptData *pScriptData ) {
	stringstream tmp;

	for( short int i = 0; i < 5; ++i ) {

		// Register3 is always set to the humanhouse 
		if( i == 3 )
			continue;

		tmp << "R" << i << ": 0x" << hex << pScriptData->Register[i];	
		tmp << "  ";
	}
	tmp << "\n";

	return tmp.str();
}

void cDebug::dumpUnit( cUnit *pUnit ) {
	stringstream tmp;

	cScriptUnitData *scriptData = (cScriptUnitData*) pUnit->scriptDataGet();
	tmp << scriptData->_unit->houseGet()->dataGet()->name;
	tmp << "[" << scriptData->_unit->indexGet() << "] ";

	tmp << " PC: " << scriptData->scriptLine;
	tmp << "  Regs: ";
	tmp << dumpRegisters( scriptData );

	write(0, tmp.str(), false);
}

void cDebug::dumpUnits( cHouse *pHouse ) {
	multimap< uint32_t, cUnit* >			*units;
	multimap< uint32_t, cUnit* >::iterator unitIT;

	units = pHouse->unitsGet();

	for( unitIT = units->begin(); unitIT != units->end(); ++unitIT ) {
		dumpUnit( unitIT->second );
	}

}

void cDebug::dumpStructure( cStructure *pStructure ) {

}

void cDebug::dumpStructures( cHouse *pHouse ) {
	multimap< uint32_t, cStructure* >				*structures;
	multimap< uint32_t, cStructure* >::iterator	 structureIT;

	structures = pHouse->structuresGet();

	for( structureIT = structures->begin(); structureIT != structures->end(); ++structureIT ) {

	}

}

void cDebug::dumpHouses() {
	map< eHouse, cHouse* >				*houses = engineGet()->housesGet();
	map< eHouse, cHouse* >::iterator	 houseIT;
	stringstream	tmp;

	for( houseIT = houses->begin(); houseIT != houses->end(); ++houseIT ) {

		tmp << "[" << houseIT->second->houseIDGet() << "]: " << houseIT->second->dataGet()->name;
		tmp << "\n";
	
		dumpUnits( houseIT->second );
	}

	write( 0, tmp.str() );
}

bool cDebug::commandSetVar( string pParameters ) {
	
	if( pParameters == "build" )
		engineGet()->gameImmediateBuild( true );

	return false;
}

bool cDebug::commandChangeHouse( string pParameters ) {
	uint32_t House = atoi(pParameters.c_str());
	
	engineGet()->houseSet( (eHouse) House );

	return false;
}

bool cDebug::commandContinue( string pParameters ) {
	
	_break = false;
	return false;
}

bool cDebug::commandHelp( string pParameters ) {
	stringstream			 response;
	const dbgCommand		*Items = _commands;
	
	write( 0, "Commands" );

	for(Items = _commands; Items->_Command; Items++) {
		response.str("");
		response << "'" << Items->_CommandShort << "' :  " << Items->_Details;

		write(0, response );
	}

	return true;
}

bool cDebug::commandDump( string pParameters ) {

	if(!pParameters.size()) {
		dumpHouses();		
	}

	return true;
}

bool cDebug::commandScenario( string pParameters ) {
	uint32_t scenario = atoi(pParameters.c_str());

	engineGet()->missionStart( engineGet()->houseHumanGet()->houseIDGet(), scenario );

	return false;
}

void cDebug::commandSetup() {
	static const dbgCommand cmdHelp[24] = {
	    {"setting",	"set",	"set variable",	&cDebug::commandSetVar},
	    {"house",	"ch","change house",	&cDebug::commandChangeHouse},
	    {"continue","x", "continue game",	&cDebug::commandContinue},
	    {"dumpo",	"d", "Dump an object",	&cDebug::commandDump},
	    {"help",	"h", "Show this help",	&cDebug::commandHelp},
	    {"scen",	"",  "Load scenario",	&cDebug::commandScenario},
	    {0},
	};

	_commands = cmdHelp;

}

bool cDebug::commandProcess( string pCommand ) {
	const dbgCommand		*Items = _commands;
	string					 parameters;
	
	uint32_t					 pos;
	pos = pCommand.find(" ");

	if(pos!=string::npos)
		parameters = pCommand.substr(pos+1);

	pCommand = pCommand.substr(0, pos);

	for(Items = _commands; Items->_Command; Items++) {
		
		if( pCommand.compare( Items->_Command ) == 0 || (pCommand == Items->_CommandShort) ) {
			if(Items->_Func) {
				return (this->*Items->_Func)( parameters );
			}
			//return -1;
		}
	}

	return true;
}

bool cDebug::cycle() {

	const SDL_Event &Event = engineGet()->sdlEventGet();
	
	if(Event.type == SDL_KEYUP ) {
		SDL_KeyboardEvent  key = Event.key;	
		
		if( key.keysym.sym == SDLK_d && key.keysym.mod & KMOD_LCTRL) {

			_break = true;
			
			write( 0, "Debugger Entered", true);
		}
	}
	
	if(_break) {

		while( commandProcess( prompt("") ));
		
	}

	return true;
}

string cDebug::prompt( string pText ) {
	string response;
	
	write( 0, pText );
	write( 0, ">", false );

	getline( cin, response );

	return response;
}

void cDebug::write( uint32_t pWidth, string pText, bool pEndLine ) {
	

	cout << setw(pWidth) << pText;
	if(pEndLine)
		cout << endl;
}

void cDebug::write( uint32_t pWidth, stringstream &pText, bool pEndLine) { 
	write( pWidth, pText.str(), pEndLine);  
}