/// <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++;
}
}
