private void OnDestinationSelected(Target?obj)
{
if (!obj.HasValue)
{
return;
}
Target value = obj.Value;
if (value.type == Target.Type.Coord)
{
if (m_selectedEntity == null)
{
SetTargetingPhase(null);
return;
}
Coord coord = value.coord;
AbstractFightAdminCommand.SendAdminCommand(new AdminRequestCmd
{
Teleport = new AdminRequestCmd.Types.TeleportAdminCmd
{
TargetEntityId = m_selectedEntity.id,
Destination = coord.ToCellCoord()
}
});
m_movingEntity = new Tuple <IEntityWithBoardPresence, Coord>(m_selectedEntity, coord);
m_selectedEntity = null;
FightMap fightMap = m_fightMap;
fightMap.onTargetSelected = (Action <Target?>)Delegate.Remove(fightMap.onTargetSelected, new Action <Target?>(OnDestinationSelected));
EndTargetingPhase();
}
}
public override IEnumerator UpdateView(FightStatus fightStatus)
{
MonoBehaviour monoBehaviour = Main.monoBehaviour;
List <IEntityWithBoardPresence> removedEntities = m_removedEntities;
int count = removedEntities.Count;
for (int i = 0; i < count; i++)
{
IEntityWithBoardPresence entity = removedEntities[i];
MonoBehaviourExtensions.StartCoroutineImmediateSafe(monoBehaviour, RemoveEntityFromBoard(entity), null);
}
if (GameStatus.fightType == FightType.BossFight && fightStatus.endReason == FightStatusEndReason.Lose)
{
FightMap current = FightMap.current;
if (null != current)
{
if (fightStatus.TryGetEntity((PlayerStatus p) => p.teamIndex == GameStatus.localPlayerTeamIndex, out PlayerStatus entityStatus))
{
HeroStatus heroStatus = entityStatus.heroStatus;
if (heroStatus != null)
{
Vector2Int refCoord = heroStatus.area.refCoord;
current.AddHeroLostFeedback(refCoord);
}
}
MonoBehaviourExtensions.StartCoroutineImmediateSafe(monoBehaviour, current.ClearMonsterSpawnCells(fightStatus.fightId), null);
}
}
if (fightStatus == FightStatus.local && !GameStatus.hasEnded)
{
yield return(DisplayFightResultFeedback(fightStatus));
}
}
public IEnumerable<IEntity> Filter(IEnumerable<IEntity> entities, DynamicValueContext context)
{
if (ZoneAreaFilterUtils.SingleTargetToCompareArea(refDirectionTargetA, context, out Area area) && ZoneAreaFilterUtils.SingleTargetToCompareArea(refDirectionTargetB, context, out Area area2))
{
Direction? dirOpt = area.refCoord.GetStrictDirection4To(area2.refCoord);
if (dirOpt.HasValue)
{
List<Area> applyAreas = ListPool<Area>.Get();
applyAreas.AddRange(ZoneAreaFilterUtils.TargetsToCompareAreaList(applyStartTargets, context));
int applyAreaCount = applyAreas.Count;
foreach (IEntity entity in entities)
{
IEntityWithBoardPresence entityWithBoardPresence = entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
for (int i = 0; i < applyAreaCount; i++)
{
Area area3 = applyAreas[i];
if (distance.Matches(entityWithBoardPresence.area.MinDistanceWith(area3), context) && entityWithBoardPresence.area.IsAlignedWith(area3) && area3.GetStrictDirection4To(entityWithBoardPresence.area) == dirOpt)
{
yield return entity;
break;
}
}
}
}
ListPool<Area>.Release(applyAreas);
}
}
}
public IEnumerable <IEntity> Filter(IEnumerable <IEntity> entities, DynamicValueContext context)
{
List <Area> areas = ListPool <Area> .Get();
areas.AddRange(ZoneAreaFilterUtils.TargetsToCompareAreaList(targetsToCompare, context));
int areaCount = areas.Count;
foreach (IEntity entity in entities)
{
IEntityWithBoardPresence entityWithBoardPresence = entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
for (int i = 0; i < areaCount; i++)
{
Area other = areas[i];
if (distance.Matches(entityWithBoardPresence.area.MinDistanceWith(other), context) && entityWithBoardPresence.area.IsAlignedWith(other))
{
yield return(entity);
break;
}
}
}
}
ListPool <Area> .Release(areas);
}
public static IEnumerable <Area> TargetsToCompareAreaList(ITargetSelector targetToCompare, DynamicValueContext context)
{
IEntitySelector entitySelector = targetToCompare as IEntitySelector;
if (entitySelector != null)
{
foreach (IEntity item in entitySelector.EnumerateEntities(context))
{
IEntityWithBoardPresence entityWithBoardPresence = item as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
yield return(entityWithBoardPresence.area);
}
}
}
ICoordSelector coordSelector = targetToCompare as ICoordSelector;
if (coordSelector != null)
{
foreach (Coord item2 in coordSelector.EnumerateCoords(context))
{
yield return(new PointArea((Vector2Int)item2));
}
}
}
public Cell(Vector2Int coords, CellState state, IEntityWithBoardPresence entity)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
this.coords = coords;
this.state = state;
this.entity = entity;
}
public static string EntityHasIncompatibleView <T>(IEntityWithBoardPresence entity)
{
IsoObject view = entity.view;
if (!(null == view))
{
return($"{entity.GetType().Name} entity with id {entity.id} has a view of type {((object)entity.view).GetType().Name} that does not implement {typeof(T).Name}.");
}
return(EntityHasNoView(entity));
}
private static IEnumerator RemoveEntityFromBoard(IEntityWithBoardPresence entity)
{
IsoObject view = entity.view;
ICharacterObject characterObject;
if ((characterObject = (view as ICharacterObject)) != null)
{
yield return(characterObject.Die());
}
view.DetachFromCell();
view.Destroy();
}
protected override void Update()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (m_movingEntity != null)
{
IEntityWithBoardPresence item = m_movingEntity.Item1;
if (m_movingEntity.Item2.Equals(item.area.refCoord))
{
SetTargetingPhase(null);
m_movingEntity = null;
}
}
}
public IEnumerable <IEntity> Filter(IEnumerable <IEntity> entities, DynamicValueContext context)
{
if (ZoneAreaFilterUtils.SingleTargetToCompareArea(m_areaOfEntity, context, out Area area))
{
foreach (IEntity entity in entities)
{
IEntityWithBoardPresence entityWithBoardPresence = entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null && area.Intersects(entityWithBoardPresence.area))
{
yield return(entity);
}
}
}
}
public bool TryGetEntityBlockingMovementAt(Vector2Int position, out IEntityWithBoardPresence entityBlockingMovement)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
foreach (EntityStatus value in m_entities.Values)
{
IEntityWithBoardPresence entityWithBoardPresence;
if (!value.isDirty && (entityWithBoardPresence = (value as IEntityWithBoardPresence)) != null && entityWithBoardPresence.blocksMovement && entityWithBoardPresence.area.Intersects(position))
{
entityBlockingMovement = entityWithBoardPresence;
return(true);
}
}
entityBlockingMovement = null;
return(false);
}
public IEnumerable <IsoObject> EnumerateInstantiationObjectTargets([NotNull] DynamicValueContext castTargetContext)
{
IEntitySelector entitySelector = m_originTarget as IEntitySelector;
if (entitySelector != null)
{
foreach (IEntity item in entitySelector.EnumerateEntities(castTargetContext))
{
IEntityWithBoardPresence entityWithBoardPresence = item as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
yield return(entityWithBoardPresence.view);
}
}
}
}
public void UpdateTarget(Vector2Int targetCellCoords, IEntityWithBoardPresence targetEntity)
{
ICharacterObject characterObject;
if (targetedEntity != null && (characterObject = (targetedEntity.view as ICharacterObject)) != null)
{
characterObject.ShowSpellTargetFeedback(isSelected: false);
}
ICharacterObject characterObject2;
if (targetEntity != null && (characterObject2 = (targetEntity.view as ICharacterObject)) != null)
{
characterObject2.ShowSpellTargetFeedback(isSelected: true);
}
targetedEntity = targetEntity;
}
private void OnEntitySelected(Target?obj)
{
if (!obj.HasValue)
{
return;
}
Target value = obj.Value;
if (value.type == Target.Type.Entity)
{
IEntityWithBoardPresence entityWithBoardPresence = value.entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
SetTargetingPhase(entityWithBoardPresence);
}
}
}
public IEnumerable <IEntity> Filter(IEnumerable <IEntity> entities, DynamicValueContext context)
{
DynamicValueFightContext dynamicValueFightContext = context as DynamicValueFightContext;
if (dynamicValueFightContext != null && TryGetSrcEntityCoords(context, out Coord srcCoord))
{
FightStatus fightStatus = dynamicValueFightContext.fightStatus;
foreach (IEntity entity in entities)
{
IEntityWithBoardPresence entityWithBoardPresence = entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null && IsPathEmptyBetween(dest: new Coord(entityWithBoardPresence.area.refCoord), fightStatus: fightStatus, src: srcCoord, context: context))
{
yield return(entityWithBoardPresence);
}
}
}
}
private void SetTargetingPhase(IEntityWithBoardPresence entity)
{
if (entity == null)
{
m_fightMap.SetTargetingPhase(EnumerateEntitiesAsTargets <IEntityWithBoardPresence>());
FightMap fightMap = m_fightMap;
fightMap.onTargetSelected = (Action <Target?>)Delegate.Remove(fightMap.onTargetSelected, new Action <Target?>(OnDestinationSelected));
FightMap fightMap2 = m_fightMap;
fightMap2.onTargetSelected = (Action <Target?>)Delegate.Combine(fightMap2.onTargetSelected, new Action <Target?>(OnEntitySelected));
}
else
{
m_fightMap.SetTargetingPhase(EnumerateValidCellsFor(entity));
FightMap fightMap3 = m_fightMap;
fightMap3.onTargetSelected = (Action <Target?>)Delegate.Remove(fightMap3.onTargetSelected, new Action <Target?>(OnEntitySelected));
FightMap fightMap4 = m_fightMap;
fightMap4.onTargetSelected = (Action <Target?>)Delegate.Combine(fightMap4.onTargetSelected, new Action <Target?>(OnDestinationSelected));
}
m_selectedEntity = entity;
}
public IEnumerable <IEntity> Filter(IEnumerable <IEntity> entities, DynamicValueContext context)
{
List <Area> areas = ZoneAreaFilterUtils.TargetsToCompareAreaList(targetsToCompare, context).ToList();
foreach (IEntity entity in entities)
{
IEntityWithBoardPresence entityWithBoardPresence = entity as IEntityWithBoardPresence;
if (entityWithBoardPresence != null)
{
foreach (Area item in areas)
{
if (distance.Matches(entityWithBoardPresence.area.MinSquaredDistanceWith(item), context))
{
yield return(entity);
break;
}
}
}
}
}
public void UpdateTarget([CanBeNull] IEntityWithBoardPresence targeted)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
if (targetedEntity == targeted)
{
return;
}
if (targetedEntity != null)
{
IObjectTargetableByAction objectTargetableByAction;
if ((objectTargetableByAction = (targetedEntity.view as IObjectTargetableByAction)) != null)
{
objectTargetableByAction.ShowActionTargetFeedback(trackedCharacter.actionType, isSelected: false);
m_objectsTargetableByAction.Add(objectTargetableByAction);
}
Vector2Int refCoord = targetedEntity.area.refCoord;
int cellIndex = stateProvider.GetCellIndex(refCoord.get_x(), refCoord.get_y());
Cell cell = grid[cellIndex];
grid[cellIndex] = new Cell(refCoord, cell.state & ~CellState.Targeted, targetedEntity);
}
if (targeted != null)
{
IObjectTargetableByAction objectTargetableByAction2;
if ((objectTargetableByAction2 = (targeted.view as IObjectTargetableByAction)) != null)
{
objectTargetableByAction2.ShowActionTargetFeedback(trackedCharacter.actionType, isSelected: true);
m_objectsTargetableByAction.Add(objectTargetableByAction2);
}
Vector2Int refCoord2 = targeted.area.refCoord;
int cellIndex2 = stateProvider.GetCellIndex(refCoord2.get_x(), refCoord2.get_y());
Cell cell2 = grid[cellIndex2];
grid[cellIndex2] = new Cell(refCoord2, cell2.state | CellState.Targeted, targeted);
}
targetedEntity = targeted;
}
public bool End()
{
StopCharacterFocus();
if (isActive)
{
Dictionary <int, Target> targets = m_targets;
foreach (Target value in targets.Values)
{
ICharacterObject characterObject;
IEntityWithBoardPresence entityWithBoardPresence;
if (value.type == Target.Type.Entity && (entityWithBoardPresence = (value.entity as IEntityWithBoardPresence)) != null && (characterObject = (entityWithBoardPresence.view as ICharacterObject)) != null)
{
characterObject.HideSpellTargetFeedback();
}
}
targets.Clear();
m_data.Clear();
m_hasEnded = true;
targetedEntity = null;
isActive = false;
return(true);
}
return(false);
}
protected override void ApplyMovement(Vector2Int[] path, ICharacterEntity trackedCharacter, IEntityWithBoardPresence targetedEntity)
{
FightState instance = FightState.instance;
if (instance != null)
{
if (targetedEntity != null)
{
instance.frame.SendEntityAttack(trackedCharacter.id, path, targetedEntity.id);
}
else if (path.Length > 1)
{
instance.frame.SendEntityMovement(trackedCharacter.id, path);
}
}
}
protected IEnumerable <Target> EnumerateValidCellsFor(IEntityWithBoardPresence entity)
{
return(from r in (entity is MechanismStatus) ? CellValidForMechanismFilter.EnumerateCells(m_fightStatus) : CellValidForCharacterFilter.EnumerateCells(m_fightStatus)
select new Target(r));
}
protected abstract void ApplyMovement(Vector2Int[] path, [NotNull] ICharacterEntity trackedCharacter, [CanBeNull] IEntityWithBoardPresence targetedEntity);
private void UpdateSystems()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_0244: Unknown result type (might be due to invalid IL or missing references)
FightMapInputHandler inputHandler = m_inputHandler;
if (!inputHandler.Update(m_mapDefinition))
{
return;
}
if (m_objectFocusedByCursor != null)
{
m_objectFocusedByCursor.SetFocus(value: false);
m_objectFocusedByCursor = null;
}
FightMapCellPointerManager cellPointerManager = m_cellPointerManager;
Vector2Int?targetCell = inputHandler.targetCell;
if (targetCell.HasValue)
{
Vector2Int value = targetCell.Value;
if (TryGetRegionIndex(value, out int regionIndex))
{
FightMapMovementContext fightMapMovementContext = m_movementContexts[regionIndex];
fightMapMovementContext.entityProvider.TryGetEntityAt(value, out IEntityWithBoardPresence character);
CellObject referenceCell = m_virtualGrid.GetReferenceCell(value);
if (null != referenceCell)
{
cellPointerManager.SetCursorPosition(referenceCell);
cellPointerManager.ShowCursor();
}
else
{
cellPointerManager.HideCursor();
}
IObjectWithFocus objectWithFocus;
if (character != null && (objectWithFocus = (character.view as IObjectWithFocus)) != null)
{
objectWithFocus.SetFocus(value: true);
m_objectFocusedByCursor = objectWithFocus;
}
if (m_pathFinder.tracking)
{
if (fightMapMovementContext == m_activeMovementContext)
{
ICharacterEntity trackedCharacter = fightMapMovementContext.trackedCharacter;
bool flag;
if (fightMapMovementContext.canDoActionOnTarget)
{
IEntityWithBoardPresence entityWithBoardPresence = null;
if (character != null && character != trackedCharacter && (fightMapMovementContext.GetCell(value).state & FightMapMovementContext.CellState.Targetable) != 0)
{
entityWithBoardPresence = character;
}
fightMapMovementContext.UpdateTarget(entityWithBoardPresence);
flag = (entityWithBoardPresence != null);
}
else
{
flag = false;
}
if (fightMapMovementContext.canMove)
{
if (flag)
{
if (trackedCharacter.hasRange)
{
m_pathFinder.Reset();
}
else
{
m_pathFinder.Move(fightMapMovementContext.stateProvider, fightMapMovementContext.grid, value, isTargeting: true);
}
}
else if ((fightMapMovementContext.GetCell(value).state & (FightMapMovementContext.CellState.Reachable | FightMapMovementContext.CellState.Occupied)) == FightMapMovementContext.CellState.Reachable)
{
m_pathFinder.Move(fightMapMovementContext.stateProvider, fightMapMovementContext.grid, value, isTargeting: false);
}
else
{
m_pathFinder.Reset();
}
}
cellPointerManager.SetAnimatedCursor(flag);
}
else
{
m_pathFinder.Reset();
cellPointerManager.SetAnimatedCursor(value: false);
}
m_feedbackNeedsUpdate = true;
}
else
{
if (m_interactiveMode != InteractiveMode.Target || onTargetChanged == null)
{
return;
}
if (m_targetContext.TryGetTargetAt(value, out Target target))
{
if (target.type == Target.Type.Entity && target.entity == character)
{
m_targetContext.UpdateTarget(value, character);
}
else
{
m_targetContext.UpdateTarget(value, null);
}
onTargetChanged(target, referenceCell);
}
else
{
m_targetContext.UpdateTarget(value, null);
onTargetChanged(null, null);
}
}
return;
}
}
if (m_pathFinder.tracking)
{
m_pathFinder.Reset();
m_feedbackNeedsUpdate = true;
}
m_cellPointerManager.HideCursor();
if (m_interactiveMode == InteractiveMode.Target)
{
onTargetChanged?.Invoke(null, null);
}
}
public static string EntityHasNoView(IEntityWithBoardPresence entity)
{
return($"{entity.GetType().Name} entity with id {entity.id} doesn't have a valid view.");
}
