public void OnMouseEnter() { Unit unit = Unit.current; UnitAction unitAction = unit.Actions()[actionIndex].GetComponent <UnitAction>(); StanceInformation.Show(unitAction.Name(), unitAction.MpCost().ToString(), unitAction.actionType().ToString() + " -- " + unitAction.Description()); }
public void Ready(SpawnPointScript spawnPoint, PlayerScript player, Unit unit) { _targetingData = new UnitTarget(); _hoveredState = HoveredState.NotHovered; _unitAction = UnitAction.Idle; _unit = unit; _playerScript = player; _spawnPointScript = spawnPoint; transform.localPosition = Vector3.zero; _unitSprite.flipX = !_playerScript.IsMe; _spawnPointScript.SetOccupied(); _selectorArrows = new GameObject[_arrowInstanceCount]; for (int i = 0; i < _arrowInstanceCount; i++) { _selectorArrows[i] = Instantiate(_selectorArrow, transform); _selectorArrows[i].GetComponentInChildren <SpriteRenderer>().enabled = false; if (i != _arrowInstanceCount - 1) { _selectorArrows[i].transform.localScale *= 0.7f; } } _sleepEffect.SetActive(true); UpdateTexts(); ReadyEvents(); }
public void Act(UnitAction action) { switch (action.ActionType) { case Constants.ActionType.MOVE: // If we successfully update our position on the grid, move to that tile if (GameComponents.GridController.MoveUnit(this, action.Target)) { Movement.StartMoving(action.Target.GetPositionWithOffset()); Debug.Log($"{Id} moved"); } break; case Constants.ActionType.ATTACK: Unit target = GameComponents.UnitRegistry.GetUnit(action.Target.StoredId); if (target) { Attack(target); Debug.Log($"{Id} attacked"); } break; default: break; } }
public bool UpdateAction(ref UnitAction action, bool current = false) { Vector3Int workCell; bool success = false; if (World.instance.ClosestAvailableCell(m_controller.unit, action.target, m_action.interactionCell, out workCell)) { /*if (current && m_action.interactionCell != workCell) * { * World.instance.ReleaseCell(m_controller.unit, m_action.interactionCell); * World.instance.ReserveCell(m_controller.unit, workCell); * }*/ action.targetCell = action.target.cell; action.targetPosition = World.instance.CellToWorld(action.targetCell); action.interactionCell = workCell; action.interactionPosition = World.instance.CellToWorld(workCell); action.distance = World.Distance(m_controller.unit, action.target); //action.status = UnitAction.ActionStatus.Planned; success = true; } else { action.status = UnitAction.ActionStatus.Cancelled; } return(success); }
/** * 전투로 인한 데미지 출력 시 MakeMessage 함수 * 인자로 UnitAction:Attack을 받지 않으면 에러 메세지 띄움. 추후 확장 가능성도 있음. */ public void MakeAttackMessage(Unit subject, UnitAction action, Unit target, int damage) { //switch case by Subject and Action. string s = "Error: MakeAttackMessage가 call되었으나 string이 제대로 생성되지 않았습니다."; if (action != UnitAction.Attack) // 잘못된 호출 { Debug.Log("정의되지 않은 방법으로 MakeAttackMessage를 호출하였습니다."); return; } if (subject.ToString() == "Player") //플레이어 공격 { s = ""; s += SubjName(subject); s += " "; // "당신은 " s += ObjName(target); s += " 공격하여 "; // "당신은 대상을 " s += damage; s += "의 피해를 주었습니다."; // "당신은 대상을 공격하여 1의 피해를 주었습니다." } else // 플레이어 방어 { s = ""; s += SubjName(subject); s += " "; // "적이 " s += ObjName(target); s += " 공격하여 "; // "적이 당신을 공격하여 " s += damage; s += "의 피해를 주었습니다."; // "적이 당신을 공격하여 1의 피해를 주었습니다." } logger.AddLog(s); }
void enterAttack(UnitAction fromState, Unit u) { unit.anim.SetBool("Walk", false); //we're in range! unit.SwitchState(fromState, UnitAction.Attacking); target = u; }
private void lmousedown(float x, float y) { foreach (GameObject obj in list) { if (obj == null) { continue; } Unit info = obj.GetComponent <Unit>(); if (info == null) { continue; } switch (info.unittype) { case "unit": case "Unit": { UnitAction action = obj.GetComponent <UnitAction>(); if (action == null) { continue; } int[] i = { 0 }; float[] f = { x, y }; action.add("useweapon", 1, i, f); } break; } } }
public void resolveAction(UnitAction action) { if (action is DamagingAction) { Debug.Log("Applying damage"); action.target.takeDamage(((DamagingAction)action).damage); if (action.target.isEnemy) { enemyNetDamageTaken += ((DamagingAction)action).damage; } else { playerNetDamageTaken += ((DamagingAction)action).damage; } } else if (action is HealingAction) { Debug.Log("Applying healing"); action.target.takeHealing(((HealingAction)action).healing); if (action.target.isEnemy) { enemyNetDamageTaken -= ((HealingAction)action).healing; } else { playerNetDamageTaken -= ((HealingAction)action).healing; } } else { } }
public void EndTargetting(bool cancel = false) { Cursor.visible = true; _unitAction = UnitAction.Idle; for (int i = 0; i < _arrowInstanceCount; i++) { _selectorArrows[i].GetComponentInChildren <SpriteRenderer>().enabled = false; } if (!cancel && _targetingData.currentTarget != null && _targetingData.validator(_targetingData.currentTarget.Unit)) { _targetingData.onComplete(_targetingData.currentTarget); } if (_targetingData.currentTarget != null) { _targetingData.currentTarget.HideTargetIndicator(_targetingData.onValidTargetMouseExit); SetDeathMarkerActive(false); } _targetingData.onComplete = (a) => { }; _targetingData.onInvalidTarget = (a) => { }; _targetingData.currentTarget = null; }
/// <summary> /// Tells the unit to follow the specified path, then attack the unit at the end of the path. /// </summary> /// <param name="path">The path to be followed by this unit</param> /// <param name="unit">The unit to be attacked at the end of the path</param> public void TravelPathAndAttack(List <BattleHex> path, BattleUnit unit) { HexDirection finalFacingDirection = TravelPath(path); BattleHex unitTile; //this._actions.la if (path.Count > 1) { unitTile = path[path.Count - 1]; } else { unitTile = _currentHex; } HexDirection requiredDirection = HexHelpers.GetTargetDirection(unitTile, unit.CurrentHexTile); if (requiredDirection != finalFacingDirection) { this._actions.Enqueue(new UnitRotation(this, HexHelpers.GetTargetDegrees(HexHelpers.ReverseDirection(finalFacingDirection)), HexHelpers.GetTargetDegrees(requiredDirection))); } this._actions.Enqueue(new UnitAttack(this, unit)); if (this._currentAction == null) { this._currentAction = this._actions.Dequeue(); } }
private void Start() { unitAction = UnitAction.Idle; unitState = UnitState.Inactive; highlight.SetActive(false); }
private void rmousedown(float x, float y) { foreach (GameObject obj in list) { if (obj == null) { continue; } Unit info = obj.GetComponent <Unit>(); if (info == null) { continue; } switch (info.unittype) { case "unit": case "Unit": { UnitAction action = obj.GetComponent <UnitAction>(); if (action == null) { continue; } action.add("movedest", 1, null, new float[] { x, y, 2 }); } break; } } }
public async UniTask <UnitActionPlanResult> PlanBatchedAction(IUnit[] units, UnitAction action) { // Action Plan Event _logger.Log(LoggedFeature.Units, $"Action: {action} planned on {units.Length} units."); _batchedActionHandlers.Where(x => x.ActionType == action).ToList() .ForEach(x => x.HandleActionPlanned(units)); // Subscribe to confirm / cancel. They will fire before Tick if possible. UnitActionPlanResult result = null; var confirmObservables = _batchedActionHandlers.Where(x => x.ActionType == action).Select(x => x.ConfirmActionObservable); confirmObservables.Merge().Subscribe(coords => { HandleActionConfirmed(units, action); result = UnitActionPlanResult.MakeConfirmed(); }).AddTo(_disposables); var cancelObservables = _batchedActionHandlers.Where(x => x.ActionType == action).Select(x => x.CancelActionObservable); cancelObservables.Merge().Subscribe(coords => { HandleActionCanceled(units, action); result = UnitActionPlanResult.MakeCanceled(); }).AddTo(_disposables); // Wait until result is received await UniTask.WaitUntil(() => result != null); return(result); }
public async UniTask <UnitActionPlanResult> PlanAction(IUnit unit, UnitAction action) { // Action Plan Event HandleActionPlanned(unit, action); // Subscribe to confirm / cancel. They will fire before Tick if possible. UnitActionPlanResult result = null; var confirmObservables = _actionHandlers.Where(x => x.ActionType == action).Select(x => x.ConfirmActionObservable); confirmObservables.Merge().Subscribe(coords => { HandleActionConfirmed(unit, action); result = UnitActionPlanResult.MakeConfirmed(); }).AddTo(_disposables); var cancelObservables = _actionHandlers.Where(x => x.ActionType == action).Select(x => x.CancelActionObservable); cancelObservables.Merge().Subscribe(coords => { HandleActionCanceled(unit, action); result = UnitActionPlanResult.MakeCanceled(); }).AddTo(_disposables); // Wait until result is received await UniTask.WaitUntil(() => result != null); return(result); }
IEnumerator walkTo(Vector3 pos) { anim.SetBool("Walk", true); Vector3 startPos = t.position; SetFacing(pos.x > startPos.x); float length = Vector3.Distance(t.position, pos); float start = Time.time; float time = 0.0f; if (pos == startPos) { // Debug.Log("[DamageEvent] already there"); yield break; } actionState |= UnitAction.Walking; while (time < 1.0f) { float dist = (Time.time - start) * speed; time = dist / length; transform.position = Vector3.Lerp(startPos, pos, time); yield return(null); } transform.position = pos; anim.SetBool("Walk", false); actionState &= ~UnitAction.Walking; }
private bool CanExecute(UnitAction action, World.Maps.HexPoint focus) { switch (action) { case UnitAction.Found: if (Game.GetCityAt(focus) != null) return false; foreach( HexPoint pt in focus.Neighbors ) if (Game.GetCityAt(pt) != null) return false; return true; case UnitAction.BuildRoad: if (road == null) road = Provider.GetImprovement("Road"); return !Game.Map[focus].Improvements.Contains(road); case UnitAction.BuildFarm: if (road == null) road = Provider.GetImprovement("Farm"); return !Game.Map[focus].Improvements.Contains(farm); } return false; }
// //Aqui vc coloca sua lógica public override void Step(Squad squad) { if (squad.TargetInfo == null || !squad.TargetInfo.IsValid) { foreach (var squaddie in squad.Units) { squaddie.CurrentAction = UnitAction.IdleAction(); } return; } if (squad.TargetInfo.Target == null) { foreach (var squaddie in squad.Units) { squaddie.CurrentAction = UnitAction.MoveAction(squad.TargetInfo.Position); } } else { foreach (var squaddie in squad.Units) { squaddie.CurrentAction = UnitAction.AttackAction(squad.TargetInfo.Target, squad.TargetInfo.Target.position); } } }
public IEnumerator Execute() { while (true) { UnitAction.activeSource = GetComponent <UnitController>(); UpdatePlan(); UnitAction action = plan.Pop(); Debug.Log(action.GetType()); if (action != null) { if (typeof(ToggleAction).IsAssignableFrom(action.GetType())) { ((ToggleAction)action).RunToggleAction(); yield return(null); } else { UnitAction.activeSource = GetComponent <UnitController>(); yield return(StartCoroutine(action.RunAction())); } } else { yield return(null); } } }
public void AddAction(UnitAction action) { if (remainingActions <= 0) { return; } remainingActions--; // SET UI switch (action.GetActionType()) { case UnitAction.ActionType.FIX: FindObjectOfType <GameUI>()?.AddHeroHUDRepair(unitNumber); SoundSystem.Instance.PlayHeroConfirmSound(unitNumber); break; case UnitAction.ActionType.MOVE: FindObjectOfType <GameUI>()?.AddHeroHUDMove(unitNumber); SoundSystem.Instance.PlayHeroMoveSound(unitNumber); TileManager.Instance.OnUnitMovedToTile(action.GetActionTarget(), unitNumber); break; } actions.Add(action); }
public virtual void DealDamage(Damage dmg) { if (state == UnitState.Dead || state == UnitState.Zombie) { return; } // Debug.Log("[Unit] " + this.gameObject + " taking " + dmg.amount + " from " + dmg.source, gameObject); hp -= dmg.amount; hp = Math.Max(hp, 0); OnDamageTaken.Invoke(dmg); if (hp == 0) { // Debug.Log("[Unit] DEAD!"); state = UnitState.Dead; m.units.Remove(this); actionState = (UnitAction)0; fx.Spawn(Keys.Death); Destroy(gameObject); } else { displayDamageFX(dmg); } }
/** * 아이템과 관련된 메세지를 출력하는 함수 * 상황에 따라 3가지 오버로딩 */ // 보통 아이템 관련 메세지 출력하는 오버로딩 함수 public void MakeItemMessage(UnitAction action, ItemManager.Label item) { string s = ""; if (action == UnitAction.EatCapsule) { Debug.Log("정의되지 않은 방법으로 MakeItemMessage를 호출하였습니다." + " EatCapsule로 call시 물 섭취 여부를 true/false로 입력하세요."); return; } if (action == UnitAction.PickItem || action == UnitAction.TakeCapsule) //아이템 습득 { if (itemmanager.GetItemIdentificationInfo(item) == false) { s = "미식별 알약을 얻었습니다."; } else { s = ObjName(item) + " 얻었습니다."; } } else if (action == UnitAction.UseItem || action == UnitAction.InjectItem) // 아이템(소모품) 사용 { s = ObjName(item) + " 사용했습니다."; } else { Debug.Log("정의되지 않은 방법으로 MakeItemMessage를 호출하였습니다."); return; } logger.AddLog(s); }
public void Run(UnitAction action) { if (action.target != null && action.target == m_action.target) { // continue action; m_action.status = UnitAction.ActionStatus.Planned; return; } else { // reserve a new cell for the interaction /*if (m_action.interactionCell != action.interactionCell) * { * World.instance.ReleaseCell(m_controller.unit, m_action.interactionCell); * World.instance.ReserveCell(m_controller.unit, action.interactionCell); * }*/ m_action = action; m_navigation.isStopped = false; m_action.status = UnitAction.ActionStatus.Planned; m_time = 0; if (action.target) { building = action.target as BuildingBase; unit = action.target as Unit; resource = action.target as ResourceSource; } } }
//If We're not moving we assume we're attacking public void ShowActionTiles(UnitAction unitAction) { m_unitView = unitAction.unit; HideActionTiles(m_unitView); Vector3 unitPosition = unitAction.unit.transform.position; m_activatedTiles.Clear(); int unitX = Mathf.RoundToInt(unitPosition.x); int unitY = Mathf.RoundToInt(unitPosition.z); int actionRange = unitAction.isMoving ? m_unitView.UnitData.movementRange : m_unitView.UnitData.weapon.weaponRange; for (int x = -actionRange; x <= actionRange; x++) { for (int y = -actionRange; y <= actionRange; y++) { if (x == 0 && y == 0) { continue; } if (Mathf.Abs(x) + Mathf.Abs(y) > actionRange) { continue; } int xPos = unitX + x; int yPos = unitY + y; Vector3 worldPoint = new Vector3(xPos, 0, yPos); if (IsPositionWithinBoard(xPos, yPos)) { bool actionable = !(Physics.CheckSphere(worldPoint, 0.4f, unitAction.collisionMask)); if (unitAction.isMoving) { if (actionable) { PathRequestManager.RequestPath(unitPosition, new Vector3(xPos, 0, yPos), OnPathFound); } } else if (!unitAction.isMoving) { actionable = !actionable; //Reverse collision bool as we're looking for tiles with animals if (actionable) { m_tileGrid[xPos, yPos].SetActive(true); m_activatedTiles.Add(m_tileGrid[xPos, yPos]); } } } } } }
public void Set(UnitAction action) { StopCurrent(); queue.Clear(); Add(action); }
// Add an action to the list and start it if is the only action public void AddAction(UnitAction action) { actions.Add(action); if (actions.Count == 1) { action.StartAction(); } }
private void HandleActionCanceled(IUnit unit, UnitAction action) { _logger.Log(LoggedFeature.Units, $"Action: {action} canceled on unit: {unit}"); _actionHandlers.Where(x => x.ActionType == action).ToList().ForEach(x => x.HandleActionCanceled(unit)); _disposables.ForEach(x => x.Dispose()); _disposables.Clear(); }
private GameObject buildSpriteOption(Sprite sprite, UnitAction choice) { GameObject go = Instantiate(MenuSpritePrefab) as GameObject; go.GetComponent <SpriteRenderer>().sprite = sprite; go.GetComponent <MenuOption>().Setup(this, choice); return(go); }
public BuildAction(GameObject owner, GameObject gameObject, Vector3 position, UnitAction postBuildAction) : base(owner) { GameObject = gameObject; Position = position; PostBuildAction = postBuildAction; }
public UnitActionTransition(UnitAI ai, UnitAction from, UnitAction to, UnitFunction precondition, double propability = 1.0) { _ai = ai; _from = from; _to = to; _precondition = precondition; _propability = propability; }
public void AttackInit() { if (!m_hasPerformedOperation) { UnitAction unitAction = new UnitAction(m_unitView, false, m_unitView.UnitData.weapon.weaponTargetMask); GameManager.Instance.ActionTiles.ShowActionTiles(unitAction); } }
public void IndicateUnitAction(UnitCell unit, UnitAction unitAction) { if (!IsCurrentPlayer) { return; } actions.SetUnitAction(unit, unitAction); }
private void TileRightClickEvent(Tile tile) { if (IsActivePlayerUnit(selectedUnit) && IsValidTarget(selectedUnit, tile)) { UnitAction action = new UnitAction(tile, Constants.ActionType.ATTACK); selectedUnit.Act(action); GameComponents.TurnHandler.EndTurn(); } }
// run away to the node that's farthest away from all enemies. private KeyValuePair<Result, UnitAction> RunAway() { MinPriorityQueue<UnitAction> farthestActions = new MinPriorityQueue<UnitAction>(); foreach (Node n in pathManager.getAccessibleNodes(subjectRef)) { int curCount = 0; foreach (Unit en in subjectsEnemiesRef) curCount += Node.range(n, en.getNode()); // min priority queue: negate results. UnitAction runAwayTo = new UnitAction(subjectRef, null, n); farthestActions.Enqueue(runAwayTo, -curCount); } if (farthestActions.Count == 0) return new KeyValuePair<Result, UnitAction>(Result.NothingFound, UnitAction.DoNothing(subjectRef)); else return new KeyValuePair<Result, UnitAction>(Result.Success, farthestActions.Dequeue()); }
protected virtual void EveryPeriod () { if (action != null) { if (!action.isactive) { action = null; } else if (action.IsEndAction()) { action = null; } } }
public virtual bool StartAction (UnitAction _action) { if (action != null) { if (!action.isactive) { action = _action; action.StartAction(); return true; } else if (_action.priory > action.priory) { if (InterruptAction()) { action = _action; action.StartAction(); return true; } } } else { action = _action; action.StartAction(); return true; } return false; }
public void Update() { if (delayTime <= 0 && !moving) { if (aiTurn && toActAI.Count == 0) { selectionState = State.EnemyTurn; foreach (Unit unit in aiUnits) toActAI.Enqueue(unit); if (toActAI.Count == 0) { moving = true; UIManager.getUIManager().clearDisplay(); pathFinder.clearRangeDisplay(); return; } } if (aiTurn) { currentAIUnit = toActAI.Dequeue(); UIManager.getUIManager().setDisplayedUnit(currentAIUnit); pathFinder.displayRangeOfUnit(currentAIUnit, currentAIUnit.getNode().getPos()); currentAction = ai.RunAI(currentAIUnit, playerUnits); UIManager.getUIManager().setDisplayedUnit(currentAIUnit); lockMovement(); currentAction.Move(finishedMoveCallbackAI); } if (!aiTurn && toActAI.Count == 0) { selectionState = State.EnemyTurn; foreach (Unit unit in playerUnits) toActAI.Enqueue(unit); if (toActAI.Count == 0) { moving = true; UIManager.getUIManager().clearDisplay(); pathFinder.clearRangeDisplay(); return; } } if (!aiTurn) { currentAIUnit = toActAI.Dequeue(); UIManager.getUIManager().setDisplayedUnit(currentAIUnit); pathFinder.displayRangeOfUnit(currentAIUnit, currentAIUnit.getNode().getPos()); currentAction = ai.RunAI(currentAIUnit, aiUnits); UIManager.getUIManager().setDisplayedUnit(currentAIUnit); lockMovement(); currentAction.Move(finishedMoveCallbackAI); } else { selectionState = State.OurTurnNoSelection; if (Input.GetMouseButtonDown((int)MouseButton.left)) { Vector2 position = getMousePos(); if (positionInGraph(position)) { Node clickedNode = pathFinder.closestMostValidNode(position); if (unitSelected) { currentlySelectedUnit.deselect(); unitSelected = false; selectionState = State.OurTurnNoSelection; } if (clickedNode.Occupied) { currentlySelectedUnit = clickedNode.Occupier; currentlySelectedUnit.select(); unitSelected = true; pathFinder.displayRangeOfUnit(currentlySelectedUnit, position); if (currentlySelectedUnit.isEnemy()) selectionState = State.UnitActed; else selectionState = State.UnitFresh; } else { pathFinder.clearRangeDisplay(); selectionState = State.OurTurnNoSelection; } } } if (Input.GetMouseButtonDown((int)MouseButton.right)) { pathFinder.clearRangeDisplay(); selectionState = State.OurTurnNoSelection; } } } else { // disables all buttons while locked selectionState = State.EnemyTurn; if (delayTime > 0) delayTime--; } UIManager.getUIManager().ChangeButtonState(selectionState); }
public void ProcessUnitAction(Unit unit, UnitAction action) { if (action is MoveAction) Move(unit, (MoveAction)action); else if (action is ScanAction) Scan(unit, (ScanAction)action); else if (action is ShootAction) Shoot(unit, (ShootAction)action); }
public virtual bool InterruptAction () { if (action != null) { if (!action.isactive) { action = null; return true; } if (!action.uninterrupt) { action.StopAction(); action = null; return true; } } else { return true; } return false; }
public void Execute(UnitAction _action) { switch (_action) { case UnitAction.Idle: break; case UnitAction.Found: Found(); break; case UnitAction.Move: SelectTarget(); break; case UnitAction.BuildRoad: if (road == null) road = Provider.GetImprovement("Road"); Build(road); break; case UnitAction.BuildFarm: if (farm == null) farm = Provider.GetImprovement("Farm"); Build(farm); break; default: throw new Exception("No handle for " + _action); } UpdateUnitAction(); }
/// <summary> /// Runs MinMax on a unit. /// </summary> /// <returns>A result-UnitAction pair.</returns> private KeyValuePair<Result, UnitAction> MinMax() { List<Node.NodePointer> targets = pathManager.getCurrentTargets(subjectRef); MinPriorityQueue<UnitAction> bestMoves = new MinPriorityQueue<UnitAction>(); int realclay = subjectRef.getClay(); // The "max-y" part: maximize (damage/counter-damage) foreach (Node.NodePointer candidateAttackTarget in targets) { int moveCost = candidateAttackTarget.getDist(); Unit curEnemy = candidateAttackTarget.getTarget().Occupier; AttackRound util = new AttackRound(subjectRef, moveCost, curEnemy); UnitAction roundMove = new UnitAction(subjectRef, curEnemy, candidateAttackTarget.getStart()); int totDmg = 0; // Will very likely die, enqueue this move as bad, and don't move to next step. //TODO: utility = 0 if (util.attackerDies() || util.getUtility() == 0) { bestMoves.Enqueue(roundMove, double.PositiveInfinity); util.resetBack(); subjectRef.setClay(realclay); continue; } totDmg += util.getExpectedDamage(); // Loop through all things that could attack this position, and continue testing attacks. // The "min-y" part. Enemy tries to maximize their (damage/counter-damage) // Technically could just do damage maximization, since counter-damage is fixed. foreach (Unit enemy in subjectsEnemiesRef) { if (enemy.getClay() > 0 && pathManager.canAttack(enemy, candidateAttackTarget.getStart())) { //gets the closest move. This will be the move that maxes damage. int enemyMoveCost = pathManager.maxDamageMoveCost(enemy, candidateAttackTarget.getStart()); AttackRound subRound = new AttackRound(enemy, enemyMoveCost, subjectRef); int roundClay = subjectRef.getClay(); subRound.resetBack(); subjectRef.setClay(roundClay); // If we die, break early, as usual. if (util.defenderDies()) { break; } totDmg += subRound.getExpectedCounterDamage(); } } // Died. Enqueue with +inf again. if (subjectRef.getClay() == 0) bestMoves.Enqueue(roundMove, double.PositiveInfinity); // enqueue move! min pri queue, so invert answer. else bestMoves.Enqueue(roundMove, -((double)totDmg / subjectRef.getClay())); util.resetBack(); subjectRef.setClay(realclay); } subjectRef.setClay(realclay); // no local targets... if (bestMoves.Count == 0) return new KeyValuePair<Result, UnitAction>(Result.NothingFound, null); // all moves die. only move is not to play. else if (bestMoves.currentInversePriority(bestMoves.Peek()) == double.PositiveInfinity) return new KeyValuePair<Result, UnitAction>(Result.WillDie, bestMoves.Peek()); // found good target. return new KeyValuePair<Result, UnitAction>(Result.Success, bestMoves.Peek()); }
public Unit(UnitType t, Sector s, Player p, DateTime d) { this.type = t; this.sector = s; this.owner = p; this.date = d; this.action = UnitAction.None; this.hitpoints = Info.Hitpoints; this.number = 1; Sector.Units.Add(this); if (Owner != null) Owner.Units.Add(this); }
private KeyValuePair<Result, UnitAction> FindUnit() { Predicate<Node> findEn = (Node q) => { bool isOccupied = q.Occupied; if (!isOccupied) return false; if (q.Occupier.isEnemy() != subjectRef.isEnemy()) return true; return false; }; Node closestEnemyNode = pathManager.getClosestNode(subjectRef, findEn); if (closestEnemyNode == null) return new KeyValuePair<Result, UnitAction>(Result.NothingFound, null); Queue<Node> path = new Queue<Node>(); pathFinderRef.AStar(path, subjectRef.getNode(), closestEnemyNode, closestEnemyNode); Node goTo = subjectRef.getNode(); // go to farthest path. while (path.Count > 0 && pathManager.canWalkTo(subjectRef, path.Peek())) goTo = path.Dequeue(); UnitAction moveCloserToClosestEnemy = new UnitAction(subjectRef, null, goTo); return new KeyValuePair<Result, UnitAction>(Result.Success, moveCloserToClosestEnemy); }