///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Alinea a la criatura en el conjunto contrario en donde este alineada
// la criatura hCriatureEnemy. En caso de que dicha criatura no este
// alineada en ningun grupo, la alineacion no se llevara a cabo.
// Parametros:
// - hCriature. Entidad a la que se desea alinear.
// - hCriatureEnemy. Entidad contra la que se quiere alinear
// Devuelve:
// - Si ha sido posible realizar la operacion true. En caso contrario false.
// Notas:
///////////////////////////////////////////////////////////////////////////////
bool
CCombatSystem::SetAlingmentAgainst(const AreaDefs::EntHandle& hCriature,
const AreaDefs::EntHandle& hCriatureEnemy)
{
// SOLO si insancia inicializada
ASSERT(IsInitOk());
// SOLO si parametros validos
ASSERT_MSG(IsValidCombatient(hCriature), "SetAlingmentAgainst_1");
ASSERT_MSG(IsValidCombatient(hCriatureEnemy), "SetAlingmentAgainst_2");
// Se obtiene la alineacion de hCriatureEnemy
const CombatSystemDefs::eCombatAlingment EnemyAlingment = GetAlingment(hCriatureEnemy);
// ¿Hay alineacion?
if (EnemyAlingment) {
// Se alinea a la entidad en el bando contrario y se retorna
if (EnemyAlingment == CombatSystemDefs::PLAYER_ALINGMENT) {
SetAlingment(hCriature, CombatSystemDefs::ENEMYPLAYER_ALINGMENT);
} else {
SetAlingment(hCriature, CombatSystemDefs::PLAYER_ALINGMENT);
}
return true;
}
// No se pudo realizar alineacion
return false;
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Atendera a las notificaciones de destruccion de entidades. Si una entidad
// va a destruirse y se halla alineada en combate, se tomara como si hubiera
// muerto, quitando su alineacion de combate.
// Parametros:
// - NotifyType. Tipo de notificacion.
// - udParam. Parametro asociado
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
CCombatSystem::WorldObserverNotify(const WorldObserverDefs::eObserverNotifyType& NotifyType,
const dword udParam)
{
// SOLO si instancia inicializada
ASSERT(IsInitOk());
// Comprueba que la notificacion sea la buscada
switch(NotifyType) {
case WorldObserverDefs::ENTITY_DESTROY: {
// ¿La entidad destruida es una criatura?
const RulesDefs::eEntityType Type = m_pWorld->GetEntityType(udParam);
if (Type == RulesDefs::CRIATURE ||
Type == RulesDefs::PLAYER) {
// ¿La entidad destruida se halla alineada?
const CombatSystemDefs::eCombatAlingment Alingment = GetAlingment(udParam);
if (Alingment != CombatSystemDefs::NO_ALINGMENT) {
// Si, estaba alineada, se quita su alineacion
// Nota: Es seguro que la criatura NO sera el jugador
SetAlingment(udParam, CombatSystemDefs::NO_ALINGMENT);
}
}
} break;
}; // ~ switch
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Finaliza el combate de tal forma que todas las criaturas que estuvieran
// alineadas dejaran de estarlo a excepcion del jugador, que seguira estando
// alineado en su conjunto de alineacion en combate.
// Parametros:
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
CCombatSystem::EndCombat(void)
{
// ¿Esta activo el modo combate?
if (IsCombatActive()) {
// Se toma la alineacion actual del jugador
const CombatSystemDefs::eCombatAlingment PlayerAlingment = GetAlingment(m_pWorld->GetPlayer()->GetHandle());
// Se procede a quitar la alineacion de todas las criaturas en combate
// asi como la informacion relativa a la lista de turnos de combate
RemoveAlingment(m_AlingmentInfo.PlayerMap);
RemoveAlingment(m_AlingmentInfo.EnemyPlayerMap);
m_CombatTurnInfo.TurnList.clear();
m_CombatTurnInfo.WaitingForCombat.clear();
// Se desvincula cualquier iterador de combate
m_CombatTurnInfo.CriatureInTurn.CriatureIt = m_CombatTurnInfo.TurnList.end();
m_CombatTurnInfo.CriatureInTurn.ActionPoints = 0;
// Se pasa el universo de juego a modo real
m_pWorld->SetMode(WorldDefs::REAL_MODE);
// Se pasa interfaz principal a modo real y se desactiva interfaz de combate
m_pGUIManager->MainInterfazSetMode(WorldDefs::REAL_MODE);
m_pGUIManager->SetCombatWindow(0);
// Se baja flag
m_bIsCombatActive = false;
// ¿Estaba alineado el jugador?
// Nota: es muy importante llamar despues de bajar el flag de combate
if (PlayerAlingment) {
ASSERT((PlayerAlingment == CombatSystemDefs::PLAYER_ALINGMENT) != 0);
SetAlingment(m_pWorld->GetPlayer()->GetHandle(), PlayerAlingment);
}
// Notifica la finalizacion del modo combate
ASSERT(SYSEngine::GetWorld()->GetPlayer());
m_pVMachine->OnEndCombatMode(this,
m_pWorld->GetScriptEventFile(RulesDefs::SE_ONENDCOMBATMODE));
}
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Alinea a la criatura en el mismo conjunto en donde este alineada
// la criatura hCriatureFriend. En caso de que dicha criatura no este
// alineada en ningun grupo, la alineacion no se llevara a cabo.
// Parametros:
// - hCriature. Entidad a la que se desea alinear.
// - hCriatureFriend. Entidad con la que se desea alinear.
// Devuelve:
// - Si ha sido posible realizar la operacion true. En caso contrario false.
// Notas:
///////////////////////////////////////////////////////////////////////////////
bool
CCombatSystem::SetAlingmentWith(const AreaDefs::EntHandle& hCriature,
const AreaDefs::EntHandle& hCriatureFriend)
{
// SOLO si insancia inicializada
ASSERT(IsInitOk());
// SOLO si parametros validos
ASSERT_MSG(IsValidCombatient(hCriature), "SetAlingmentWith_1");
ASSERT_MSG(IsValidCombatient(hCriatureFriend), "SetAlingmentWith_2");
// Se obtiene la alineacion de hCriatureFriend
const CombatSystemDefs::eCombatAlingment FriendAlingment = GetAlingment(hCriatureFriend);
// ¿Hay alineacion?
if (FriendAlingment) {
// Se alinea a la entidad en dicho bando y retorna
SetAlingment(hCriature, FriendAlingment);
return true;
}
// No se pudo realizar alineacion
return false;
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recibe la notificacion de una criatura sobre un determinado suceso en
// la misma o cambio de estado.
// - A la hora de recibir la notificacion de la realizacion de una accion,
// se tendra en cuenta si esta bloqueado o no el uso de los puntos de accion.
// Parametros:
// - hCriature. Handle a la criatura.
// - NotifyType. Tipo de suceso.
// - udParam. Posible parametro.
// Devuelve:
// Notas:
// - En caso de que no se este en modo combate, se obviaran las notificaciones
// - Cuando la notificacion provenga del jugador, se tendra en cuenta los
// sig. aspectos:
// * Si hay ptos de accion insuficientes -> NO se pasara de turno.
// * Si al restar puntos, estos quedan a 0 -> NO se pasara SI se esta
// en la interfaz PlayerProfile.
// - El codigo de la accion a realizar en udParam, SIEMPRE, ira en el word
// inferior.
///////////////////////////////////////////////////////////////////////////////
void
CCombatSystem::CriatureObserverNotify(const AreaDefs::EntHandle& hCriature,
const CriatureObserverDefs::eObserverNotifyType& NotifyType,
const dword udParam)
{
// SOLO si instancia inicializada
ASSERT(IsInitOk());
// SOLO si parametros validos
ASSERT_MSG(IsValidCombatient(hCriature), "CriatureObserverNotify");
// ¿NO se esta en modo combate?
if (!IsCombatActive()) {
// Si, se abandona
return;
}
// Se comprueba el tipo de notificacion recibida
switch (NotifyType) {
case CriatureObserverDefs::IS_DEATH: {
// La criatura ejecuto el evento de muerte
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
// ¿Es el jugador?
if (pCriature->GetEntityType() == RulesDefs::PLAYER) {
// Si, se finaliza el combate
EndCombat();
} else {
// No, se desvincula a la criatura del combate
SetAlingment(hCriature, CombatSystemDefs::NO_ALINGMENT);
}
} break;
case CriatureObserverDefs::ACTION_REALICE: {
// ¿Criatura con turno?
if (hCriature == GetCriatureInTurn()) {
// ¿NO esta bloqueado el uso de puntos de accion?
if (!m_bActionPointsBlocked) {
// Se toma la accion a realizar y sus puntos de accion
const RulesDefs::eCriatureAction Action = RulesDefs::eCriatureAction(udParam & 0x0000FFFF);
// Se comprueba si se esta realizando alguna accion especial o
// bien una accion no considerada como que gasta puntos de combate
RulesDefs::CriatureActionPoints ActionCost = 0;
switch(Action) {
case RulesDefs::CA_USEHABILITY: {
// Se obtiene el identificador de la habilidad en los primeros 16 bits
const RulesDefs::eIDHability IDHability = RulesDefs::eIDHability(udParam >> 16);
ActionCost = m_pGDBase->GetRulesDataBase()->GetUseHabilityCost(IDHability);
} break;
case RulesDefs::CA_HIT: {
// Se obtiene el slot con el que se golpea y los ptos asociados
const RulesDefs::eIDEquipmentSlot Slot = RulesDefs::eIDEquipmentSlot(udParam >> 16);
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
CItem* const pItem = m_pWorld->GetItem(pCriature->GetEquipmentSlots()->GetItemEquipedAt(Slot));
ActionCost = (NULL == pItem) ? 0 : m_pGDBase->GetRulesDataBase()->GetUseWeaponItemCost(pItem->GetType());
} break;
case RulesDefs::CA_DROPITEM:
case RulesDefs::CA_STOPWALK: {
// No se considerara gasto en puntos de combate
return;
} break;
}; // ~ switch
// Se añaden los puntos base de coste de la accion realizada
ActionCost += m_pGDBase->GetRulesDataBase()->GetCombatActionCost(Action);
// Se decrementan los puntos de accion y se actualizan en ventana
ASSERT((ActionCost <= m_CombatTurnInfo.CriatureInTurn.ActionPoints) != 0);
m_CombatTurnInfo.CriatureInTurn.ActionPoints -= ActionCost;
ASSERT((m_CombatTurnInfo.CriatureInTurn.ActionPoints >= 0) != 0);
m_pGUIManager->CombatSetActionPoints(m_CombatTurnInfo.CriatureInTurn.ActionPoints);
// ¿Ya no quedan puntos de accion?
if (0 == m_CombatTurnInfo.CriatureInTurn.ActionPoints) {
// Se notifica de tal forma que se ejecute el case INSUFICIENT_ACTION_POINTS
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
// Si la entidad es un NPC, se pasara de turno automaticamente
if (RulesDefs::CRIATURE == pCriature->GetEntityType()) {
NextTurn(hCriature);
} else {
// En caso contrario se trata del jugador y se pasara de turno
// SOLO si NO se esta en el interfaz de inventario.
if (m_pGUIManager->GetGameGUIWindowState() != GUIManagerDefs::GUIW_PLAYERPROFILE) {
NextTurn(hCriature);
}
}
}
}
}
} break;
case CriatureObserverDefs::INSUFICIENT_ACTION_POINTS: {
// ¿Criatura con turno?
if (hCriature == GetCriatureInTurn()) {
// Se pasara de turno si la entidad no es el jugador
if (m_pWorld->GetPlayer()->GetHandle() != hCriature) {
NextTurn(hCriature);
} else {
// En el caso de que sea el jugador se mandara mensaje a consola
SYSEngine::GetGUIManager()->WriteToConsole(m_pGDBase->GetStaticText(GameDataBaseDefs::ST_GENERAL_INSUFICIENTACTIONPOINTS),
true);
}
}
} break;
}; // ~ switch
}
void CXTPHeaderCtrl::OnAlignRight()
{
SetAlingment(LVCFMT_RIGHT);
}
void CXTPHeaderCtrl::OnAlignCenter()
{
SetAlingment(LVCFMT_CENTER);
}
void CXTPHeaderCtrl::OnAlignLeft()
{
SetAlingment(LVCFMT_LEFT);
}
