Another Star Trek Game (The Retro One)

#include "StdAfx.h"
#include "CommandManager.h"

#include "Game.h"
#include "GameData.h"
#include "Galaxy.h"
#include "ShipMonitor.h"
#include "Phaser.h"
#include "Torpedo.h"
#include "KlingonShip.h"
#include "Console.h"
#include "Controller.h"
#include "ShipDisplay.h"
#include "HelpScreen.h"

CommandManager::CommandManager()
{
  m_curValidationMode = WaitForCommand;
}

CommandManager::~CommandManager(void)
{
}

bool CommandManager::onEnter(EKEY_CODE keyCode)
{
	if (keyCode == KEY_RETURN && m_curValidationMode != WaitForAnimation)
	{
		validateCommand();
	}
	else
	{
		if (keyCode == KEY_UP)
		{
			m_pHelpScreen->lineUp();
		}
		else if(keyCode == KEY_DOWN)
		{
			m_pHelpScreen->lineDown();
		}
		else
		{
			if(m_pHelpScreen->isVisible())
			{
				m_pMonitor->setMode(ShipMonitor::SectorView);	
				m_pHelpScreen->goTop();
			}

			setReady();
		}
	}
	
	return true;
}

void CommandManager::setReady()
{
	m_curValidationMode = WaitForCommand;
	
	m_pConsole->resetConsole();
  m_pController->runEnemyAI();

	m_pDisplay->show();
	m_pHelpScreen->hide();
}

void CommandManager::setEnterprise(Enterprise* pEnterprise)
{
	m_pEnterprise = pEnterprise;
}

void CommandManager::setShipMonitor(ShipMonitor* pMonitor)
{
	m_pMonitor = pMonitor;
}

void CommandManager::setConsole(Console* pConsole)
{
	m_pConsole = pConsole;

	m_pConsole->addOnKeyPress(new KeyPressed<CommandManager>(this, &CommandManager::onEnter));

	m_pConsole->resetConsole();
}

void CommandManager::setController(Controller* pController)
{
	m_pController = pController;
}

void CommandManager::setShipDisplay(ShipDisplay* pDisplay)
{
	m_pDisplay = pDisplay;
}

void CommandManager::validateCommand()
{
	switch(m_curValidationMode)
	{
	case WaitForCommand:
		executeCommand();
		break;

	case NavigateWaitForCourse:
		storeNavigationCourse();
		break;

	case NavigateWaitForDistance:
		storeNavigationDistance();
		break;

	case LaunchWaitForEnergy:
		launchPhaserWaitForEnergy();
		break;

  case LaunchWaitForCourse:
    launchTorpedoWaitForCourse();
    break;

  case LaunchWaitForCoordinates:
    launchTorpedoWaitForCoordinates();
    break;

	case TransferWaitForEnergy:
		transferWaitForEnergy();
		break;

	default:
		//	unknown command reset
		m_pMonitor->setMode(ShipMonitor::SectorView);
		setReady();
		
    break;
	}
}


void CommandManager::storeNavigationCourse()
{
	m_dblCourse = m_pConsole->getDoubleValue();
	commandWaitForDistance();
}

void CommandManager::storeNavigationDistance()
{
	m_dblDistance = m_pConsole->getDoubleValue();

  m_pEnterprise->moveShip(m_dblCourse, m_dblDistance);
  m_pMonitor->setMode(ShipMonitor::SectorView);

	Game::getInstance()->getGameData()->timePased(0.5 * m_dblDistance);
  
  turnOver();
}

void CommandManager::executeCommand()
{
	switch(m_pConsole->getIntegerValue())
	{
	case Navigate:
		commandWaitForCourse();
		break;

	case ShortRangeScan:
		m_pMonitor->setMode(ShipMonitor::SectorView);		
    setReady();
		break;

	case LongRangeScan:
		m_pEnterprise->doLongRangeScan();
		m_pMonitor->setScanInfo(m_pEnterprise->getLongRangeScanData());
		m_pMonitor->setMode(ShipMonitor::QuadrantView);
		setReady();
		break;

	case LaunchPhaser:
		launchPhaser();
		break;

	case LaunchTorpedo:
    launchTorpedo();
		break;

	case TransferEnergy:
		transferEnergy();
		break;

	case ShowDamageReport:
		loadDamageReport();
		break;

  case UseComputer:
    useComputer();
    break;

	case ShowHelp:
		loadHelp();
		break;

	default:
		setReady();
		break;
	}
}

void CommandManager::commandWaitForCourse()
{
	m_curValidationMode = NavigateWaitForCourse;
	
	m_pConsole->addLine(L"ENTER THE COURSE (1-9):");
}

void CommandManager::commandWaitForDistance()
{
	m_curValidationMode = NavigateWaitForDistance;

	stringw wText = L"ENTER THE WARPSPEED (0-";
	wText += m_pEnterprise->getMaxWarpSpeed();
	wText += "):";

	m_pConsole->addLine(wText.c_str());
}

void CommandManager::launchPhaser()
{
	//	Check for target
	m_pConsole->addLine(L"LAUNCH PHASER");

	stringw wText = L"AMOUNT OF ENERGY AVAILABLE (";

	wText += m_pEnterprise->m_iEnergyLevel;

	wText += L")";

	m_pConsole->addLine(wText);
	m_pConsole->addLine(L"ENTER THE ENERGY TO USE:");

	m_curValidationMode = LaunchWaitForEnergy;

	Game::getInstance()->getGameData()->timePased(0.10);
}

void CommandManager::launchPhaserWaitForEnergy()
{
	m_pController->launchPhaserAtKlingon(m_pConsole->getIntegerValue());
	
	turnOver();
}

void CommandManager::animationDone()
{
}

void CommandManager::launchTorpedo()
{
  m_curValidationMode = LaunchWaitForCourse;

  m_pConsole->addLine(L"ENTER THE COURSE OF THE TORPEDO (1-9, 0 TO USE COMPUTER):");
}

void CommandManager::launchTorpedoWaitForCourse()
{
  if(m_pConsole->getIntegerValue() == 0)
  {
    //  get computer aid
    //
    m_curValidationMode = LaunchWaitForCoordinates;
		m_pConsole->addLine(L"ENTER THE COORDINATES OF KLINGON SHIP (X,Y):");
  }
  else
  {
		m_pController->launchTorpedo(m_pConsole->getDoubleValue());

		Game::getInstance()->getGameData()->timePased(0.10);

		turnOver();
  }
}

void CommandManager::launchTorpedoWaitForCoordinates()
{
  m_curValidationMode = LaunchWaitForCourse;

  double dblCourse = m_pEnterprise->getTorpedoCourse(m_pConsole->getCoordinateValue());

  stringw wText = L"CALCULATED COURSE IS: ";
  wText += dblCourse;

  m_pConsole->addLine(wText);
  m_pConsole->addLine(L"ENTER THE COURSE OF THE TORPEDO (1-9, 0 TO USE COMPUTER):");
}

void CommandManager::transferEnergy()
{
	stringw wText = L"AMOUNT OF ENERGY AVAILABLE (";

	wText += m_pEnterprise->m_iEnergyLevel;

	wText += L")";

	m_pConsole->addLine(wText);
	m_pConsole->addLine(L"ENTER THE ENERGY TO TRANSFER:");
	
	m_curValidationMode = TransferWaitForEnergy;
}

void CommandManager::transferWaitForEnergy()
{
	m_pEnterprise->transferEnergy(m_pConsole->getIntegerValue());

	m_pMonitor->setMode(ShipMonitor::SectorView);
	
  setReady();
}

void CommandManager::loadDamageReport()
{
	m_pMonitor->setMode(ShipMonitor::DamageReport);	
	setReady();
}

void CommandManager::useComputer()
{
	m_pMonitor->setMode(ShipMonitor::ComputerLog);
	setReady();
}

void CommandManager::turnOver()
{
  m_pEnterprise->updateEnterprise();

  Sector* pSector = Game::getInstance()->getGameData()->getGalaxy().getCurrentSector();

  if(pSector->getNumberofKlingons() > 0)
  {
    m_pController->allowEnemyAI();
    
    m_curValidationMode = WaitForAnimation;
  }
  else
  {
    m_curValidationMode = WaitForCommand;
  }

	m_pMonitor->setMode(ShipMonitor::SectorView);

  setReady();
}

void CommandManager::loadHelp()
{
	m_pMonitor->setMode(ShipMonitor::Help);	
	
	setReady();
	
	//	override default display setting
	m_pDisplay->hide();
	m_pHelpScreen->show();
}

void CommandManager::setHelpScreen(HelpScreen* pHelp)
{
	m_pHelpScreen = pHelp;
}