Example #1
0
///////////////////////////////////////////////////////////////////////////////
// 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;
}
Example #2
0
///////////////////////////////////////////////////////////////////////////////
// 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
}
Example #3
0
///////////////////////////////////////////////////////////////////////////////
// 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));	
  }  
}
Example #4
0
///////////////////////////////////////////////////////////////////////////////
// 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;
}
Example #5
0
///////////////////////////////////////////////////////////////////////////////
// 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    
}
Example #6
0
void CXTPHeaderCtrl::OnAlignRight()
{
	SetAlingment(LVCFMT_RIGHT);
}
Example #7
0
void CXTPHeaderCtrl::OnAlignCenter()
{
	SetAlingment(LVCFMT_CENTER);
}
Example #8
0
void CXTPHeaderCtrl::OnAlignLeft()
{
	SetAlingment(LVCFMT_LEFT);
}