// Start is called before the first frame update
void Start()
{
maxHP = 15 + (int)(level * (cups / 3 + baseHP));
maxMP = 5 + (int)(((level - 1) / 4 + 1) * (pentacles / 5 + baseMP));
currHP = maxHP;
currMP = maxMP;
turnOrder = gameObject.transform.parent.GetComponent <TurnOrder>();
}
protected override void Move()
{
WorldController.MoveToWorldPoint(transform, mapPosition, targetPosition);
mapPosition = targetPosition;
inventory.ReSelect();
ChangeAP(-1);
WorldController.SetDistanceFromPlayer();
TurnOrder.StartConcurrentTurns();
}
public void Focus()
{
Profile.Show(GetComponent <Unit>());
AdvancedProfile.Show(GetComponent <Unit>());
BuffsProfile.Show(GetComponent <Unit>());
TurnOrder.Show();
Unit.hovered = GetComponent <Unit>();
SetHighlight();
}
public void Blur()
{
Profile.Hide();
AdvancedProfile.Hide();
BuffsProfile.Hide();
TurnOrder.Hide();
Unit.hovered = null;
UnsetHighlight();
}
// Use this for initialization
void Start()
{
board = new Board().getBoard();
createParty();
createEnemies();
order = new TurnOrder(party, enemies);
nextTurn();
createBoard();
}
public static void endTurnForCurrentCharacter()
{
GameObject nextChar = TurnOrder.getNextCharacter();
BaseCommandPanelHandler bcph = GameObject.Find("CombatUI/CharacterControls/BaseCommandPanel").GetComponent <BaseCommandPanelHandler>();
bcph.enableMove();
bcph.enableAction();
nextChar.GetComponent <CombatCharacterController>().turnStart();
}
public override void SetAP(int newAP)
{
if (TurnOrder.ConcurrentTurns())
{
newAP = maxAP;
inventory.DecreaseCooldowns();
}
ap = newAP;
apUI.GetComponent <UnityEngine.UI.Text>().text = "AP: " + ap + "/" + maxAP;
}
public async Task Start(string name, Tuple <string, bool>[] phases, string[] playerOrder)
{
var game = await _gameRepository.GetByNameAsync(name);
var players = playerOrder.Select(u => game.Players.First(p => p.UserName == u));
var turnOrder = TurnOrder.Create(players.Select(PlayerTurnOrder.Create));
var phase = Phase.Create(phases.Select(p => p.Item1));
game.Start(turnOrder, phase);
}
// Start is called before the first frame update
void Start()
{
sr = GetComponent <SpriteRenderer>();
rb = GetComponent <Rigidbody>();
Turnmaker = FindObjectOfType <TurnOrder>();
if (isRandomEnemy)
{
EnemyCreator.Instance.RandomizeEnemy(this);
}
}
public override void ChangeAP(int change)
{
if (TurnOrder.ConcurrentTurns())
{
change = 0;
inventory.DecreaseCooldowns();
}
ap += change;
apUI.GetComponent <UnityEngine.UI.Text>().text = "AP: " + ap + "/" + maxAP;
}
protected void EnterTurnOrder()
{
if (WorldController.GetDistanceFromPlayer(MyPosition()) < Settings.enterTurnDistance)
{
TurnOrder.AddTurn(gameObject);
}
else
{
TurnOrder.AddConcurrentTurn(gameObject);
}
}
/// <summary>
/// Get the first turn order image for a unit.
/// </summary>
/// <param name="unit">Unit.</param>
public TurnOrderImage Get(Unit unit, TurnOrder turnOrder)
{
foreach (var image in _imageDictionary[turnOrder])
{
if (image.Unit == unit)
{
return(image);
}
}
return(null);
}
/// <summary>
/// Checks if all units are combat ready.
/// </summary>
/// <returns><c>true</c>, if all units combat ready was ared, <c>false</c> otherwise.</returns>
/// <param name="units">Units.</param>
/// <param name="turnOrder">Turn order.</param>
private bool AreAllUnitsCombatReady(List <Unit> units, TurnOrder turnOrder)
{
foreach (var unit in units)
{
if (unit.IsCombatReady(turnOrder) == false)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Awake this instance.
/// </summary>
void Awake()
{
print("TurnOrderController.Awake()");
_preSortedTurnOrder = new TurnOrder();
_turnOrderCollection = new TurnOrderCollection();
_turnOrderCollection.Primary = new TurnOrder();
_turnOrderCollection.Secondary = new TurnOrder();
_turnOrderImageCollection = new TurnOrderImageCollection(_turnOrderCollection.Primary, _turnOrderCollection.Secondary);
_panel = this.gameObject;
_dividerImage = Instantiate(_dividerPrefab);
}
/// <summary>
/// Removes all units.
/// </summary>
/// <param name="turnOrder">Turn order.</param>
public void RemoveAllUnits(TurnOrder turnOrder)
{
List <Unit> units = turnOrder.GetAllUnits();
for (int i = units.Count - 1; i >= 0; i--)
{
Unit unit = units [i];
unit.ResetTurnOrderData(turnOrder);
RemoveUnit(unit, turnOrder);
}
}
public void onClick()
{
CombatUiStateKeeper.hideCombatUi();
this._ability = AbilityFactory.getAbility(this.name);
this.abilityRangeSelection = new Range(Rangefinder.findAllTilesInRange(TurnOrder.getActiveCharacter().GetComponent <CharacterBase>().getCurrentTileOfCharacter(), this._ability.range), "ability");
this.abilityRangeSelection.colorRange();
this._targetMode = true;
CombatUiStateKeeper.jumpBackEnabled = false;
}
public void Setup()
{
_turnOrder = new TurnOrder();
GameObject testContainer = new GameObject();
testContainer.AddComponent <Ally> ();
testContainer.AddComponent <Enemy> ();
_unit1 = testContainer.GetComponent <Ally>();
_unit2 = testContainer.GetComponent <Enemy> ();
}
public void StartCombat(EnemyType type)
{
hud.turnEvents = "Plan your move...";
enemy = new Enemy(textures, type, player);
currentTurn = TurnOrder.animation;
effectPlayer = Effects.none;
effectEnemy = Effects.none;
confusedPlayer = false;
confusedEnemy = false;
player.abilities.usedAbility = UsedAbility.Miss;
enemy.ability.usedAbility = UsedAbility.Miss;
}
public void Start()
{
this._godObject = GameObject.Find("GodObject");
GameObject[] characters = GameObject.FindGameObjectsWithTag("combatCharacter");
this._godObject.GetComponent <UnitPlacementHandler>().placeUnits(characters);
TurnOrder.buildCharacterList(characters);
this._camera = Camera.main;
if (this._camera != null)
{
this._cameraController = this._camera.GetComponent <CameraController>();
}
}
public void InitializeBattle()
{
battleCanvas.SetActive(true);
GetEquipment();
InitializePlayer();
currentTurn = TurnOrder.player;
StartCoroutine(EnemyPrepareAttack());
//Debug.Log(playerStats.currentHealth);
//Debug.Log(playerStats.maxHealth.GetValue());
//Debug.Log(playerStats.damage.GetValue());
//Debug.Log(playerStats.armor.GetValue());
}
void Start()
{
turnOrder = new TurnOrder(court.TeamOne, court.TeamTwo);
foreach (var b in court.GetBallmen())
{
b.OnMoveFinished += ShowMoveButtons;
}
basicSelector = new BasicTileSelector(turnOrder);
court.TileSelector = basicSelector;
selectedBallmanMarker.SetActive(false);
UpdateSelectedPlayer();
}
private Entity GetNextInTurnOrder()
{
var lastEntity = TurnOrder.Dequeue();
TurnOrder.Enqueue(lastEntity);
while (TurnOrder.Peek().IsDead())
{
TurnOrder.Dequeue();
}
return(TurnOrder.Peek());
}
public void onClick()
{
CombatCharacterController activeCharacter = TurnOrder.getActiveCharacter().GetComponent <CombatCharacterController>();
HashSet <GameObject> foundRange = Rangefinder.findAllTilesInRange(
activeCharacter.getCurrentTileOfCharacter(),
activeCharacter.GetComponent <CombatCharacterController>().walkRange
);
CombatUiStateKeeper.hideCombatUi();
this._currentMovementRange = new Range(foundRange, "movement");
_currentMovementRange.colorRange();
this._isMovementPhase = true;
}
private bool PlayerRetreated()
{
if (PlayerDead())
{
return(false);
}
if (TurnOrder.Any(e => e.IsPlayer()))
{
return(false);
}
return(true);
}
// Start is called before the first frame update
void Awake()
{
turnOrder = FindObjectOfType <TurnOrder>();
if (!turnOrder)
{
Debug.LogError("Scene has a game manager script but no turn order");
}
uiScript = FindObjectOfType <BattleUIScript>();
if (!uiScript)
{
Debug.LogError("Scene has a game manager script but no ui script");
}
board = FindObjectOfType <BoardGenerator>();
if (!board)
{
Debug.LogError("Scene has a game manager script but no board");
}
instance = this;
//Inventory Variables
inventoryUICanvas = GameObject.FindGameObjectWithTag("InventoryUICanvas");
if (!inventoryUICanvas)
{
Debug.LogError("Scene has a game manager but no inventory UI");
}
else
{
inventoryUICanvas.SetActive(false); //defaults inventory to closed
}
//End Screen Variables
endScreenUICanvas = GameObject.FindGameObjectWithTag("EndScreenUI");
if (!endScreenUICanvas)
{
Debug.LogError("Scene has a game manager but no end screen UI");
}
endUIController = FindObjectOfType <EndUIController>();
if (!endUIController)
{
Debug.LogError("Scene has no end UI Controller");
}
else
{
endUIController.gameObject.SetActive(false);
}
clicker = FindObjectOfType <Clicker>();
m_battleManager = gameObject.AddComponent <BattleManager>();
if (!m_battleManager)
{
Debug.LogError("Battle Manager Creation Failed");
}
}
// Start is called before the first frame update
void Start()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
turnOrder = TurnOrder.Player;
playerAction = PlayerAction.Empty;
}
/// <summary>
/// Sorts the turn order.
/// </summary>
/// <param name="turnOrderCollection">Turn order collection.</param>
public void SortTurnOrder(TurnOrder turnOrder)
{
_preSortedTurnOrder.Union(turnOrder);
RemoveAllUnits(turnOrder);
if (turnOrder == _turnOrderCollection.Primary)
{
_dividerImage.transform.SetParent(null);
}
int index = 1;
do
{
foreach (var unit in _preSortedTurnOrder.GetAllUnits())
{
// Increment clocks ticks by speed attribute.
// If this bring the unit to combat readiness,
// add them to queue and set property
unit.IncrementClockTicks(turnOrder, (int)unit.GetSpeedAttribute().CurrentValue);
if (unit.GetClockTicks(turnOrder) >= CLOCK_TICKS_TILL_COMBAT_READY)
{
bool isCombatReady = unit.IsCombatReady(turnOrder);
int clockTicks = unit.GetClockTicks(turnOrder);
int roundAppearences = unit.GetRoundAppearences(turnOrder);
if (!isCombatReady || clockTicks >= CLOCK_TICKS_TILL_COMBAT_READY * (roundAppearences + 1))
{
print(string.Format("{0} - CT:{1} - Index:{2} - RoundAppearences:{3} - IsCombatReady:{4}", unit.GetFullName(), unit.GetClockTicks(turnOrder), index, roundAppearences, isCombatReady));
unit.SetCombatReady(turnOrder, true);
unit.IncrementRoundAppearences(turnOrder);
AddUnit(unit, turnOrder);
}
}
}
index++;
} while (!AreAllUnitsCombatReady(_preSortedTurnOrder.GetAllUnits(), turnOrder));
_preSortedTurnOrder.Clear();
// Add divider to separate turn order rounds
if (turnOrder == _turnOrderCollection.Primary)
{
AddDivider();
}
}
//Private
private void AI()
{
if (!TurnOrder.MyTurn(gameObject))
{
return;
}
if (ap <= 0)
{
TurnOrder.EndTurn(gameObject);
return;
}
string result = Attack();
if (result == "success")
{
return;
}
else if (result == "selected")
{
return;
}
else if (result == "outofrange")
{
if (PathToPlayer())
{
return;
}
}
else if (result == "notaligned")
{
if (LineUp(PlayerPosition()))
{
return;
}
}
else if (PathToPlayer())
{
return;
}
TurnOrder.EndTurn(gameObject);
//else if (RunAway()) return;
}
//Public
public override bool StartConcurrentTurn()
{
if (PlayerWithInRange(Settings.enterTurnDistance))
{
TurnOrder.AddTurn(gameObject);
player.GetComponent <PlayerUI>().SetMessage("Enemy In Range");
return(false);
}
if (OutOfSight())
{
MoveRandomly();
}
else
{
PathToPlayer();
}
return(true);
}
public void Update()
{
if (this._mapOverviewHandler.isOverviewMode == false)
{
if (Input.GetKey(KeyCode.Q))
{
this._inRotation = true;
this.rotateLeft(TurnOrder.getActiveCharacter().GetComponent <CombatCharacterController>().getCurrentTileOfCharacter());
}
if (Input.GetKey(KeyCode.E))
{
this._inRotation = true;
this.rotateRight(TurnOrder.getActiveCharacter().GetComponent <CombatCharacterController>().getCurrentTileOfCharacter());
}
this._inRotation = false;
}
}
void Start()
{
instance = this;
if (GameType.getGameType() != "Survival")
{
player1 = new Player(1, player1Color, GameValues.intValues["baseResources"]);
player2 = new Player(2, player2Color, GameValues.intValues["baseResources"]);
}
else
{
player1 = new Player(1, player1Color, GameValues.intValues["baseResources"] * 9);
player2 = new Player(2, player2Color, GameValues.intValues["baseResources"] * 9);
}
if(Network.isServer || GameType.getGameType() == "Local") {
myPlayer = player1;
otherPlayer = player2;
playerText.guiSkin = player1Box;
playerText.text = "Player 1";
} else {
myPlayer = player2;
otherPlayer = player1;
playerText.guiSkin = player2Box;
playerText.text = "Player 2";
}
turnNum = 0;
actionNum = 0;
ceasefire = 2;
Faction[] factions = new Faction[3] { new Totem(), new Cowboys(), new Area51() };
if (player1Bases.Length == 0)
{
Debug.Log ("Error! There are 0 Player Bases assigned.");
}
for(int i=0; i<player1Bases.Length; i++) {
player1Bases[i].SetTowerNumber(i);
player1Bases[i].SetPlayerNumber(1);
player1.AddTower(player1Bases[i], factions[i], i);
}
for(int i=0; i<player2Bases.Length; i++) {
player2Bases[i].SetTowerNumber(i);
player2Bases[i].SetPlayerNumber(2);
player2.AddTower(player2Bases[i], factions[i], i);
}
CombatLog.addLineNoPlayer("Ceasefire ends in " + (ceasefire - turnNum) + " turns.");
//Check for victory (Will prohibit building on not alive Towers
checksVictory = true;
TowerSelection.LocalSelectSection(myPlayer.GetTower(1), -1);
}
void CardOperate(Card card){
if (card.function == Card.CardFunction.Skip) {
turnOneRound ();
turnOneRound ();
}
else if (card.function == Card.CardFunction.Reverse) {
if (turnOrder == TurnOrder.clockwise)
turnOrder = TurnOrder.counterclockwise;
else if (turnOrder == TurnOrder.counterclockwise)
turnOrder = TurnOrder.clockwise;
turnOneRound ();
}
else if (card.function == Card.CardFunction.DrawTwo) {
nextDraw += 2;
showDrawCount();
turnOneRound();
}
else if (card.function == Card.CardFunction.Wild) {
changeColor();
turnOneRound();
}
else if (card.function == Card.CardFunction.WildDrawFour) {
changeColor();
nextDraw += 4;
showDrawCount();
turnOneRound();
}
else {
turnOneRound();
}
}
