/// <summary> /// Do something random. Who knows? I sure don't. /// </summary> /// <param name="hand">My hand.</param> /// <param name="state">The table state.</param> /// <returns>A random action.</returns> public TurnAction DoAction(Card[] hand, TableState state) { int randomValue = this.random.Next(1, 101); if (randomValue > 90) { return(TurnAction.Fold); } if (randomValue > 50) { return(TurnAction.Call); } int myMoney = state.Players[this.myName].Money; int raiseAmount = (randomValue / 10 + 1) * state.MinimumBet; if (raiseAmount > myMoney) { raiseAmount = myMoney; } return(TurnAction.Raise(raiseAmount)); }
public override ITurnAction Update(IBot ownBot, IBattlefield battlefield) { var enemies = battlefield.Bots.Except(new[] { ownBot }); if (ownBot.AvailableWeapons.Count == 1) { var closestWeapon = battlefield.Weapons.OrderBy(ownBot.DistanceTo).First(); return(ownBot.DistanceTo(closestWeapon) < ownBot.Radius ? TurnAction.PickUpWeapon() : TurnAction.MoveTowards(closestWeapon)); } if (enemies.Any()) { var closestEnemy = enemies.OrderBy(ownBot.DistanceTo).First(); if (ownBot.EquippedWeapon.Ammunition.Remaining > 0) { return(ownBot.DistanceTo(closestEnemy) < ownBot.EquippedWeapon.MaxRange / 2 ? TurnAction.ShootAt(closestEnemy) : TurnAction.MoveTowards(closestEnemy)); } var closestWeapon = battlefield.Weapons.OrderBy(ownBot.DistanceTo).First(); return(ownBot.DistanceTo(closestWeapon) < ownBot.Radius ? TurnAction.PickUpWeapon() : TurnAction.MoveTowards(closestWeapon)); } return(TurnAction.Idle); }
/// <summary> /// call this when a turn is over, before starting next turn /// </summary> public void ResetTurn() { actionThisTurn = TurnAction.Undecided; actionMoveDirection = new Vector3(0, 0, 0); turnFinished = false; moveTickTimer = 0; }
/// <summary> /// Execute all stacked actions, create projectiles and calculate damage /// </summary> private void ExecuteActions() { Stack <TurnAction> actionsClone = new Stack <TurnAction>(m_turnActionsStack); while (m_turnActionsStack.Count > 0) { TurnAction action = m_turnActionsStack.Pop(); //create path and get collisions with terrain ProjectilePath path = new ProjectilePath(action.Player.ControlledTank.Position, action.Force); Coordinate collisionPoint = m_terrain.GetCollisionPoint(path); //for each collision damage the terrain m_terrain.DoDamange(collisionPoint, action.Weapon); //find all tanks effected and damage them TestTanksCollisionAt(collisionPoint, action.Weapon); } // if someone is listening for action executions, // then let it know that actions were executed, and send NextTurn as callback to be called by the listenr if (ActionsExecuted != null) { ActionsExecuted(actionsClone, NextTurn); } else { //if no one listens (meaning no external use for game) skip to next Turn NextTurn(); } }
public bool PlayTurn(PlayerType player, TurnAction turnAction) { if (player == PlayerType.Player) { switch (turnAction) { case TurnAction.Hit: _player.HitMe(); break; case TurnAction.Stand: _player.Stand = true; break; default: break; } return(_player.Bust); // return property instead of doing a double check after hit } else //Dealer (Dealer will only call hit) { while (!_dealer.Stand && !_dealer.Bust) { _dealer.HitMe(); } GameOver = true; // Dealer will be done with turn when code hits here return(true); } }
private void Start() { fsm = new FSM("AITest FSM Two"); MoveForwardState = fsm.AddState("MoveForwardState"); IdleState = fsm.AddState("MoveRightState"); TurnState = fsm.AddState("TurnState"); MoveForwardAction = new MoveAction(MoveForwardState); IdleAction = new MoveAction(IdleState); TurnAction = new TurnAction(TurnState); MoveForwardState.AddAction(MoveForwardAction); IdleState.AddAction(IdleAction); TurnState.AddAction(TurnAction); MoveForwardState.AddTransition("ToTurn", TurnState); TurnState.AddTransition("ToIdle", IdleState); TurnState.AddTransition("ToTurn", TurnState); IdleState.AddTransition("ToForward", MoveForwardState); IdleState.AddTransition("ToTurn", TurnState); MoveForwardAction.Init(this.transform, .1f, 2.0f, "ToTurn"); TurnAction.Init(this.transform, 2.0f, "ToIdle"); IdleAction.Init(this.transform, 0, 2.0f, "ToForward"); fsm.Start("MoveForwardState"); }
private TurnAction[] getTurnActionsFromPathLocations(Point[] pathLocations) { TurnAction[] result = new TurnAction[pathLocations.Length]; int i = 0; while (i < pathLocations.Length - 1) { Point nextLocation = pathLocations[i + 1]; Point currentLocation = pathLocations[i]; if (currentLocation.X > nextLocation.X) { result[i] = TurnAction.WalkWest; } else if (currentLocation.X < nextLocation.X) { result[i] = TurnAction.WalkEast; } else if (currentLocation.Y > nextLocation.Y) { result[i] = TurnAction.WalkSouth; } else if (currentLocation.Y < nextLocation.Y) { result[i] = TurnAction.WalkSouth; } i++; } return(result); }
public static Location ApplyMovement(Location old, TurnAction ac) { var x = old.X; var y = old.Y; switch (ac) { case TurnAction.WalkNorth: y--; break; case TurnAction.WalkSouth: y++; break; case TurnAction.WalkEast: x++; break; case TurnAction.WalkWest: x--; break; } return(new Location(x, y)); }
public TurnAction DoTurn(PartyCharacter target) { if (this.CurrentHP > 0) { // Utilise la compétence ayant la plus grosse valeur d'attaque avec un coût en point d'action inférieur aux points d'action restant et ayant un cooldown restant de 0 Ability ability = this.Abilities.Where(i => (i.currentCooldown == 0) && (i.ActionPoint <= this.ActionPoints)).OrderByDescending(i => Math.Abs(i.Value)).FirstOrDefault(); if (ability != null) { TurnAction action = new TurnAction { Action = ability.DoAbility, ActionName = $"L'adversaire utilise la compétence {ability.Name}", Source = this, Target = target }; return(action); } // Si aucune compétence n'est utilisable else { UI.Display($"{this.Name} passe son tour !"); return(null); } } else { return(null); } }
private static Champion CreateChampion(string name, int uiSpeed) { return(new Champion(name, 0, uiSpeed, 0, 0, new List <Skill>() { new Skill("A1", Constants.SkillId.A1, 0, TurnAction.AttackOneEnemy()) })); }
// public int numPlantsAtStart = 5; public void Initialize(int numPlantsAtStart = 5) { if (turnQueue.Count > 0) { // remove stuff from previous round for (int i = 0; i < turnQueue.Count; i++) { TurnAction ta = turnQueue[i]; turnQueue[i] = null; GameObject.Destroy(ta.gameObject); } turnQueue.Clear(); } GameObject go; for (int n = 0; n < numPlantsAtStart; n++) { go = Instantiate(plantTurnPrefab, TurnActionsGroup); turnQueue.Add(go.GetComponent <TurnAction>()); } for (int n = 0; n < WeatherQueue.numDays; n++) { go = Instantiate(shapeTurnPrefab, TurnActionsGroup); turnQueue.Add(go.GetComponent <TurnAction>()); } BeginTurnTakingLoop(); }
public Turn Walk() { TurnAction direction = NextDirectionCounterClockwise(CurrentDirection); if (Request.PossibleActions.Contains(TurnAction.Loot)) { return(new Turn(TurnAction.Loot)); } else if (Request.PossibleActions.Contains(TurnAction.Attack)) { if (Request.PossibleActions.Contains(TurnAction.DrinkPotion) && Request.IsCombat && Request.PartyMember.CurrentHealthPoints < MINIMUM_HITPOINTS) { return(new Turn(TurnAction.DrinkPotion)); } return(new Turn(TurnAction.Attack)); } else if (Request.PossibleActions.Contains(direction)) { CurrentDirection = direction; } else if (!Request.PossibleActions.Contains(CurrentDirection)) { CurrentDirection = GetNextPossibleDirection(direction); } return(new Turn(CurrentDirection)); }
public ITurnAction GetTurnAction(IOwnBot ownBot, IReadOnlyCollection <IEnemy> enemies, IBattlefieldView battlefield) { if (!enemies.Any()) { return(TurnAction.Idle()); } if (ownBot.Energy.Percent < 10) { return(TurnAction.Recharge.Battery()); } var enemy = enemies.First(); if (ownBot.Health.Percent < 50 && ownBot.Shield.Percent < 50) { if (ownBot.Energy.Actual > 110) { return(TurnAction.Recharge.Shield(100)); } return(TurnAction.Move.AwayFrom(enemy.Position)); } if (ownBot.DistanceTo(enemy) < (double)Attack.MaxRange / 2) { return(TurnAction.Attack(enemy)); } return(TurnAction.Move.Towards(enemy.Position)); }
public AbilitySequenceHandler(TurnAction turnAction, Action onAbilitySequenceFinished) { currentQueue = new Queue <AbstractUnitCommand>(turnAction.QueueOfCommands); commonCommandData = turnAction.CommonCommandData; optionalCommandData = turnAction.OptionalCommandData; this.onAbilitySequenceFinished = onAbilitySequenceFinished; }
public TurnAction CalculateGOBAction(Unit unit, WorldModel currentWorldModel) { var nextQueueState = currentWorldModel.GetNextQueueState(); TurnAction bestAction = null; float bestDiscontentment = float.MaxValue; foreach (var viableAction in currentWorldModel.GetNextAction()) { var nextWorldState = new WorldModel(currentWorldModel.CopyUnits(), nextQueueState.Queue, nextQueueState.CurrentlyActiveUnit); WorldModelStack.Push(nextWorldState); nextWorldState.ApplyTurnAction(viableAction); var discontentmentForUnit = nextWorldState.GetDiscontentmentForUnit(unit); if (discontentmentForUnit < bestDiscontentment) { bestAction = viableAction; bestDiscontentment = discontentmentForUnit; } WorldModelStack.Pop(); } return(bestAction); }
public bool BeenToTarget(Location currentLocation, TurnAction action) { var loc = MovementTool.ApplyMovement(currentLocation, action); var value = LocationsTracker.Count(s => s.X == loc.X && s.Y == loc.Y) > 0; return(value); }
// TODO change arguments to link to Turn public virtual void Shoot(TurnAction tAction /*Vector3 point, float successQ*/) { this.tAction = tAction; tAction.ActionStarted = true; if (CurAmmo > 0) { VisualShot(tAction.Point); CurAmmo--; // Next -- Anim_OnShoted } else { StartCoroutine(WaitAnd(() => { tAction.ActionEnded = true; if (onShoted != null) { onShoted(); } }, .4f)); } // TODO else *click* }
public static Champion Create(string name, int baseSpeed, double effectiveSpeed) { List <Skill> skills = new List <Skill>(); skills.Add(new Skill("A1", Constants.SkillId.A1, 0, TurnAction.AttackOneEnemy())); return(new Champion(name, baseSpeed, effectiveSpeed, skills)); }
public static Champion Create(string name, int baseSpeed, int uiSpeed, int speedSets, int perceptionSets) { List <Skill> skills = new List <Skill>(); skills.Add(new Skill("A1", Constants.SkillId.A1, 0, TurnAction.AttackOneEnemy())); return(new Champion(name, baseSpeed, uiSpeed, speedSets, perceptionSets, skills)); }
public void WrongUserCantChangeTurn() { var state = Common.GameState; var action = new TurnAction("2"); Assert.False(state.TryApply(action)); Assert.Same("1", state.TurnOwner); }
private static ITurnAction GetResource(IBot ownBot, IBattlefield battlefield) { var closestResource = battlefield.Resources.OrderBy(ownBot.DistanceTo).First(); return(ownBot.DistanceTo(closestResource) < ownBot.Radius ? TurnAction.PickUpResource() : TurnAction.MoveTowards(closestResource)); }
public void TurnRight() { var turnAction = new TurnAction(); var engine = new TextAdventureEngine(new NormalLocation(), DirectionCalculator.North); turnAction.Execute(engine, new[] { "turn", "right" }); Assert.Equal(1, engine.CurrentOrientation); }
public void UserCanChangeTurn() { var state = Common.GameState; var action = new TurnAction("1"); Assert.True(state.TryApply(action)); Assert.Same("2", state.TurnOwner); }
public ITurnAction GetTurnAction( IOwnBot ownBot, IReadOnlyCollection <IEnemy> enemies, IBattlefieldView battlefield) { var enemy = enemies.FirstOrDefault(); return(enemy != null?TurnAction.Attack(enemy) : TurnAction.Idle()); }
public static Champion Create(int uiSpeed, int speedSets, int perceptionSets) { List <Skill> skills = new List <Skill>(); skills.Add(new Skill("Mallet Crescendo", Constants.SkillId.A1, 0, new TurnAction(3, Constants.Target.OneEnemy, null, null, null))); skills.Add(new Skill("Tombfire", Constants.SkillId.A2, 4, TurnAction.AttackOneEnemy())); return(new Champion("Coffin Smasher", 92, uiSpeed, speedSets, perceptionSets, skills)); }
/// <summary> /// Creates the turn action. /// </summary> /// <param name="turn">Turn.</param> /// <param name="action">Action.</param> private static void createTurnAction(int turn, AIAction action) { TurnAction turnAction = ScriptableObject.CreateInstance <TurnAction>(); turnAction.action = action; turnAction.turn = turn; _actionsHistory.Add(turnAction); }
public override void SetUp() { base.SetUp(); Enemy = Get <IBotWorkshop>().Create(TestBotAI.Idle); var turnAction = TurnAction.Attack(Enemy.OutsideView); BotAI.TurnAction = turnAction; EnergyCost = BotAI.TurnAction.EnergyCost; }
/// <summary> /// When player is done, create a turnAction and add it to the actionsStack /// </summary> /// <param name="player"></param> private void OnPlayerActionReady(Player player) { TurnAction playersAction = TurnAction.CreateTurnActionFromPlayer(player); m_turnActionsStack.Push(playersAction); if (m_turnActionsStack.Count == m_players.Count) { EndTurn(); } }
public static void Clear() { // 초기화 TurnAction turnAction = TurnAction.Wait; ActionProgress actionProgress = ActionProgress.Ready; origin.Clear(); queue.Clear(); Player.order.Clear(); }
public static Champion Create(int uiSpeed, int speedSets, int perceptionSets) { List <Skill> skills = new List <Skill>(); skills.Add(new Skill("Freezing Toxin", Constants.SkillId.A1, 0, TurnAction.AttackOneEnemy())); skills.Add(new Skill("Blood Chill", Constants.SkillId.A2, 3, TurnAction.AttackOneEnemy())); skills.Add(new Skill("Icy Veins", Constants.SkillId.A3, 3, TurnAction.AttackOneEnemy())); return(new Champion("Gravechill Killer", 96, uiSpeed, speedSets, perceptionSets, skills)); }
public GameStateTurnAction(GameState gs, long time, TurnAction action) : base(gs, time) { this.turnAction = action; }
public static void SendAction(TurnAction action) { instance.RegisterAction(action); }
private void RegisterAction(TurnAction action) { ResetMenus(); myActions[actionNum] = action; myPlayer.RemoveResources(action.cost); if(actionNum >= 2) { for(int i=0; i<3; i++) { if(Network.isClient) { networkView.RPC("RegisterAction", RPCMode.Server, i, myActions[i].GetActionMessage()); } else if(Network.isServer) { RegisterAction(i, myActions[i].GetActionMessage()); } } foreach (Menu c in GameObject.Find("MainMenu").GetComponentsInChildren<Menu>()) { c.on = false; } GameObject.FindGameObjectWithTag("Player").GetComponent<TowerInspector2>().show = false; } else { foreach (Menu c in GameObject.Find("MainMenu").GetComponentsInChildren<Menu>()) { c.on = false; } GameObject.Find("MainMenu").GetComponent<Menu>().on = true; actionNum++; } }