void RegisterAbilityButtonEvents(GameObject button)
{
AbilityButton guildAbilityButton = button.GetComponent <AbilityButton>();
UIManager.Instance.abilityDetailsPanel.OnAbilityPointPurchased += PurchaseAbilityPoints;
guildAbilityButton.OnButtonDestroyed += UnRegisterAbilityButtonEvents;
}
public void OnAbilityButtonPressed(AbilityButton abilityButton)
{
if (abilityPressedAction != null)
{
abilityPressedAction.Invoke(abilityButton.Ability);
}
}
public bool SelectAbility(AbilityButton abilityButton, Ability ability)
{
if (state.ic.GetBlocked())
{
return(false);
}
foreach (AbilityButton ab in abilityButtons)
{
if (abilityButton == ab)
{
if (selected != abilityButton)
{
state.ic.SelectAbility(ability);
state.uic.SelectAbility(ability);
selected = abilityButton;
}
else
{
ab.DeselectAbility();
state.ic.DeselectAbility();
state.uic.DeselectAbility();
selected = null;
return(false);
}
}
else
{
ab.DeselectAbility();
}
}
return(true);
}
public static void CreateButtonsForHero(Hero hero)
{
if (!buttonPrefab)
{
buttonPrefab = Resources.Load <GameObject>("Prefabs/2D/Ability Button");
}
HeroAbility ability;
int offsetX = (hero.CountAbilities() - 1) * -38; // half button
for (int index = 0; index < hero.CountAbilities(); index++)
{
ability = hero.GetAbility(index);
GameObject obj = (GameObject)Instantiate(
buttonPrefab,
Vector3.zero,
Quaternion.identity,
GameObject.Find("Canvas").transform);
obj.GetComponent <RectTransform>().anchoredPosition =
new Vector3(offsetX + 76 * index, 0, 0);
obj.name = "Button " + ability.GetAbilityName();
AbilityButton button = obj.GetComponent <AbilityButton>().Init(ability);
ability.SetUIButton(button);
}
}
// ABILITA SpaccaTeschi ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void CoPioggiaDiFrecce()
{
UiController ui = FindObjectOfType <UiController>();
ui.dpsAbilityPanel.SetActive(false);
ui.EnemyListPanel.SetActive(true);
List <Button> button = new List <Button>();
foreach (GameObject enemy in enemyDisp)
{
Button newButton = Instantiate(attacchiAriaButton);
AbilityButton enemyButton = newButton.GetComponent <AbilityButton>();
enemyButton.enemy = enemy;
enemyButton.enemyInfoPanel = ui.enemyInfoPanel;
newButton.transform.SetParent(ui.EnemyListPanel.transform, false);
newButton.onClick.AddListener(() => PioggiaDiFrecce(enemyButton.enemy));
button.Add(newButton);
}
if (button.Count > 1)
{
for (int i = 0; i <= button.Count - 1; i++)
{
int n = i;
if (i == button.Count - 1)
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[0];
custumNav.selectOnUp = button[n - 1];
button[i].navigation = custumNav;
}
else if (i == 0)
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[n + 1];
custumNav.selectOnUp = button[button.Count - 1];
button[i].navigation = custumNav;
}
else
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[n + 1];
custumNav.selectOnUp = button[n - 1];
button[i].navigation = custumNav;
}
}
}
button.Clear();
DestroyAttackBox();
ui.EnemyListPanel.transform.GetChild(0).GetComponent <Button>().Select();
}
public void SetButton(AbilityButton button)
{
AButton = button;
AButton.nameText.text = abilityName;
if (buttonIcon != null)
{
AButton.iconImage.sprite = buttonIcon;
}
}
void UnselectAbilityButton(AbilityButton button)
{
button.SetUnselected();
button.Refund();
selectedAbility = null;
buttons.ForEach(b => {
b.UpdateButtonStatus();
});
}
private void Start()
{
hero = HeroBuilder.Build(PLAYER_HERO_INDEX, this);
AbilityButton.CreateButtonsForHero(hero);
animator = GetComponentInChildren <Animator>();
destination = transform.position;
newPosition = destination;
}
public void CoManaButton()
{
UiController ui = FindObjectOfType <UiController>();
ui.EnemyListPanel.SetActive(true);
ActionPanel.SetActive(false);
GameObject[] allyDisp = GameObject.FindGameObjectsWithTag("Player");
List <Button> button = new List <Button>();
foreach (GameObject ally in allyDisp)
{
Button newButton = Instantiate(potionButton);
AbilityButton enemyButton = newButton.GetComponent <AbilityButton>();
enemyButton.enemy = ally;
enemyButton.enemyInfoPanel = ui.enemyInfoPanel;
newButton.transform.SetParent(EnemyListPanel.transform, false);
newButton.onClick.AddListener(() => Mana(enemyButton.enemy));
button.Add(newButton);
}
if (button.Count > 1)
{
for (int i = 0; i <= button.Count - 1; i++)
{
int n = i;
if (i == button.Count - 1)
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[0];
custumNav.selectOnUp = button[n - 1];
button[i].navigation = custumNav;
}
else if (i == 0)
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[n + 1];
custumNav.selectOnUp = button[button.Count - 1];
button[i].navigation = custumNav;
}
else
{
Navigation custumNav = new Navigation();
custumNav.mode = Navigation.Mode.Explicit;
custumNav.selectOnDown = button[n + 1];
custumNav.selectOnUp = button[n - 1];
button[i].navigation = custumNav;
}
}
}
button.Clear();
EnemyListPanel.transform.GetChild(0).GetComponent <Button>().Select();
}
void OnAbilitySelect(AbilityButton a)
{
selectedAbility = a;
equipButton.gameObject.SetActive(false);
unequipButton.gameObject.SetActive(false);
buyButton.gameObject.SetActive(false);
scoreCost.gameObject.SetActive(false);
fillerText.gameObject.SetActive(false);
title.gameObject.SetActive(true);
description.gameObject.SetActive(true);
title.text = a.title;
description.text = a.description;
if (a.combatAbility != Abilities.CombatAbility.None)
{
if (abilities.purchasedCombatAbilities.Contains(a.combatAbility))
{
if (abilities.CurrentCombatAbility == selectedAbility.combatAbility)
{
unequipButton.gameObject.SetActive(true);
}
else
{
equipButton.gameObject.SetActive(true);
}
scoreCost.gameObject.SetActive(false);
}
else
{
buyButton.gameObject.SetActive(true);
scoreCost.gameObject.SetActive(true);
scoreCost.text = a.scoreCost.ToString();
}
}
if (a.evasionAbility != Abilities.EvasionAbility.None)
{
if (abilities.purchasedEvasionAbilities.Contains(a.evasionAbility))
{
if (abilities.CurrentEvasionAbility == selectedAbility.evasionAbility)
{
unequipButton.gameObject.SetActive(true);
}
else
{
equipButton.gameObject.SetActive(true);
}
scoreCost.gameObject.SetActive(false);
}
else
{
buyButton.gameObject.SetActive(true);
scoreCost.gameObject.SetActive(true);
scoreCost.text = a.scoreCost.ToString();
}
}
}
public void CreateButton(IOcuppy actualOccupier, ABILITYBUTTONTYPE abilityButtonType)
{
Button btnAbi = Instantiate(abilityButtonPrefab);
btnAbi.transform.SetParent(buttonParent, false);
switch (abilityButtonType)
{
case ABILITYBUTTONTYPE.MOVE:
MoveAbilityButtonExecution moveAbilityBtnExe = new MoveAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnMove = new AbilityButton(btnAbi, moveAbilityBtnExe, null);
btnMove.Suscribe();
actualAbilityButtons.Add(btnMove);
break;
case ABILITYBUTTONTYPE.ATTACK:
AttackAbilityButtonExecution attackAbilityBtnExe = new AttackAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnAttack = new AbilityButton(btnAbi, attackAbilityBtnExe, null);
btnAttack.Suscribe();
actualAbilityButtons.Add(btnAttack);
break;
case ABILITYBUTTONTYPE.DEFEND:
DefenseAbilityButtonExecution defenseAbilityBtnExe = new DefenseAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnDefense = new AbilityButton(btnAbi, defenseAbilityBtnExe, null);
btnDefense.Suscribe();
actualAbilityButtons.Add(btnDefense);
break;
case ABILITYBUTTONTYPE.COMBINE:
break;
case ABILITYBUTTONTYPE.TAKECARD:
TakeCardAbilityButtonExecution takeCardAbilityBtnExe = new TakeCardAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnTakeCard = new AbilityButton(btnAbi, takeCardAbilityBtnExe, null);
btnTakeCard.Suscribe();
actualAbilityButtons.Add(btnTakeCard);
break;
case ABILITYBUTTONTYPE.EVOLVE:
break;
case ABILITYBUTTONTYPE.FUSION:
break;
case ABILITYBUTTONTYPE.SPAWN:
SpawnAbilityButtonExecution spawnAbilityBtnExe = new SpawnAbilityButtonExecution(actualOccupier, gameMachine, this);
AbilityButton btnSpawn = new AbilityButton(btnAbi, spawnAbilityBtnExe, null);
btnSpawn.Suscribe();
actualAbilityButtons.Add(btnSpawn);
break;
default:
break;
}
}
public GameObject SelectAbilty(GameObject ability, AbilityButton button)
{
CancelAll();
if (activeAbility)
{
Destroy(activeAbility);
}
activeAbility = (GameObject)Instantiate(ability);
activeAbility.GetComponent <Ability>().button = button;
return(activeAbility);
}
void UnselectAbilityButton(AbilityButton button)
{
currentlyActivatingAbility = false;
button.SetUnselected();
button.Refund();
uncalled(selectedAbility);
selectedAbility = null;
buttons.ForEach(b => {
b.UpdateButtonStatus();
});
}
void SelectAbilityButton(PlayerAbility ability, AbilityButton button)
{
button.SetSelected();
selectedAbility = ability;
buttons.ForEach(b => {
if (b != button)
{
b.button.interactable = false;
}
});
ConfirmMove();
}
public static void AddAbility(int index)
{
GameObject newButton = (GameObject)Instantiate(instance.buttonPrefab, new Vector3(instance.buttonSize * currentButtons.Count + instance.buttonSize / 2f, instance.buttonHeight), Quaternion.identity);
AbilityButton butt = newButton.GetComponent <AbilityButton>();
butt.ability = instance.researchableAbilities[index];
newButton.transform.SetParent(instance.contentRect.transform, false);
instance.contentRect.position = contentRectPos;
instance.contentRect.sizeDelta = new Vector2(instance.buttonSize * currentButtons.Count, instance.buttonSize);
currentButtons.Add(butt);
}
public void GenerateCurrentButtons(AbilityInfoObject characterClass)
{
foreach (AbilityInfo ability in characterClass.abilities)
{
//Create gameobject with veriables from Class/Abilities
AbilityButton newButton = Instantiate(abilityButtonPrefab, transform);
newButton.abilityName.text = ability.name;
newButton.abilityButton.GetComponent <AbilityButtonFunctions>().abilityKeybind = ability.keybind;
newButton.abilityIcon.sprite = ability.icon;
newButton.abilityKeybind = ability.keybind;
newButton.abilityTooltip = ability.tooltip;
newButton.abilityButton.onClick.AddListener(() => { ability.callbackFunction.Invoke(); });
}
}
void SelectAbilityButton(PlayerAbility ability, AbilityButton button)
{
currentlyActivatingAbility = true;
button.SetSelected();
selectedAbility = ability;
buttons.ForEach(b => {
if (b != button)
{
b.button.interactable = false;
}
});
called(selectedAbility);
}
// Use this for initialization
void Start()
{
for (int i = 0; i < aSO.abilities.Length; i++)
{
AbilityClass a = aSO.abilities[i];
GameObject g = Instantiate(buttonPrefab, this.transform);
g.name = a._name;
AbilityButton ab = g.GetComponent <AbilityButton>();
ab.label.text = a._name;
ab.icon.sprite = a.icon;
ab.index = i;
ab.aSO = aSO;
}
}
public void createbuttons(List <KeyCode> abilityHotkeys /*, player player*/)
{
List <AbilityButton> newButtons = new List <AbilityButton>();
for (int i = 0; i < 4; i++)
{
GameObject newButtonObject = Instantiate(mAbilityButtonPrefab, transform);
AbilityButton abilityButton = newButtonObject.GetComponent <AbilityButton>();
newButtons.Add(abilityButton);
}
mAllButton = newButtons;
}
void ButtonHit(AbilityButton button, PlayerActivatedPower power)
{
//This feels hacky. Better way to do this?
var ability = power as PlayerAbility;
if (ability == selectedAbility)
{
UnselectAbilityButton(button);
}
else
{
SelectAbilityButton(ability, button);
}
}
public AbilityButton Clone(string name, Vector3 posOffset)
{
GameObject newBut = (GameObject)MonoBehaviour.Instantiate(gameObject);
newBut.name = name;
AbilityButton abilityButton = newBut.GetComponent <AbilityButton>();;
abilityButton.Init();
newBut.transform.SetParent(transform.parent);
newBut.transform.localPosition = transform.localPosition + posOffset;
newBut.transform.localScale = transform.localScale;
newBut.transform.localRotation = transform.localRotation;
return(abilityButton);
}
public void SetupAbilityHolder(HackerMod hackerMod, AbilityButton newAbilityButton)
{
abilityButton = newAbilityButton;
mod = hackerMod;
abilityText.text = mod.GetItemAbilityDescription();
if (abilityButton.GetRemainingUses() == 1)
{
usesText.text = "1 use";
}
else
{
usesText.text = abilityButton.GetRemainingUses().ToString() + " uses";
}
abilityIcon.sprite = FindObjectOfType <AllHackAbilityIcons>().GetAbilityIconById(mod.GetActiveAbilityId());
}
private void StartStage(Stage stage)
{
playerMoveController = stage.PlayerEntity.GetComponent <MoveController>();
playerMoveController.OnActionDeselected += DeselectAbility;
abilities = stage.PlayerEntity.GetComponents <Ability>();
foreach (Ability ability in abilities)
{
AbilityButton abilityButton = abilityPanel.AddElement(abilityButtonPrefab).GetComponent <AbilityButton>();
abilityButton.AttachAbility(ability);
abilityButton.OnSelect += PressAbility;
abilityButtons.Add(abilityButton);
}
}
public void SetUnit(Unit unit, bool forceRefresh)
{
if (unit == currentUnit && !forceRefresh)
{
return;
}
if (currentUnit != null)
{
(currentUnit.Health as Health).OnHealthEvent.RemoveListener(OnUnitHealthEvent);
}
currentUnit = unit;
int i = 0;
if (unit != null)
{
(currentUnit.Health as Health).OnHealthEvent.AddListener(OnUnitHealthEvent);
UpdateHealth(currentUnit.Health);
healthBarSlider.gameObject.SetActive(true);
foreach (Ability ability in unit.Abilities)
{
if (i > abilityButtons.Count)
{
Debug.LogWarning("Too many abilities for UI to display");
break;
}
AbilityButton abilityButton = abilityButtons[i];
abilityButton.SetAbility(ability, hotkeys[i].ToString());
i++;
}
}
else
{
healthBarSlider.gameObject.SetActive(false);
}
for (; i < abilityButtons.Count; i++)
{
abilityButtons[i].SetAbility(null, null);
}
unitNameLabel.text = unit != null ? unit.Name : "";
UpdateItemsUi(unit);
}
private void UpdateBallType(bool turnOn, AbilityButton abilityButton)
{
if (turnOn)
{
activeButton?.SetSelected(false);
activeButton = abilityButton;
OnBallTypeChanged?.Invoke(abilityButton.BallType);
return;
}
if (!turnOn && abilityButton == activeButton)
{
activeButton.SetSelected(false);
activeButton = null;
OnBallTypeChanged?.Invoke(BallType.Normal);
}
}
void Reset()
{
titleText.text = "";
statusText.text = "";
statusDetailsText.text = "";
statusDetails2Text.text = "";
abilitiesText.text = "";
abilitiesDetailsText.text = "";
for (int i = 0; i < maxAbilities; i++)
{
AbilityButton b = abilityButtons[i];
b.gameObject.SetActive(false);
}
currentUnit = null;
}
void ButtonHit(AbilityButton button, PlayerActivatedPower ability)
{
button.ToggleSelected();
//This feels hacky. Better way to do this?
var modifier = ability as PlayerAbilityModifier;
if (button.IsSelected())
{
modifierSelected(modifier);
}
else
{
modifierUnselected(modifier);
}
buttons.ForEach(b => b.UpdateButtonStatus());
}
public void SetUnit(Unit unit)
{
List <Ability> abilities = unit.stats.GetAbilities();
for (int i = 0; i < abilities.Count; ++i)
{
abilityButtons[i].SetAbility(abilities[i], unit);
}
List <Ability> itemAbilities = unit.stats.GetItemAbilities();
for (int i = 0; i < itemAbilities.Count; ++i)
{
abilityButtons[abilities.Count + i].SetAbility(itemAbilities[i], unit);
}
for (int i = 0; i < generalAbilities.Count; ++i)
{
abilityButtons[itemAbilities.Count + abilities.Count + i].SetAbility(generalAbilities[i], unit);
}
selected = null;
}
void Start()
{
this.gameData = GameObject.FindGameObjectWithTag("GameData").GetComponent <GameData>();
int i = 0;
foreach (KeyValuePair <Ability, float> entry in gameData.abilityTimers)
{
AbilityButton abilityButton = new AbilityButton();
abilityButton.button = Instantiate(UIButtonPrefab, this.gameObject.transform);
var abilityImage = abilityButton.button.GetComponent <Image>();
abilityImage.color = new Color(255, 255, 255, 0);
abilityImage.sprite = (Sprite)AssetDatabase.LoadAssetAtPath(AbilityExtensions.GetImagePath(entry.Key), typeof(Sprite));
abilityImage.transform.localScale = new Vector3(0f, 0f, 0f);
abilityButton.button.GetComponent <RectTransform>().localPosition = new Vector3(0, TOP_OFFSET, 0);
abilityButton.abilityState = AbilityState.EXITED;
abilityButton.ability = entry.Key;
activeAbilities[i] = abilityButton;
i++;
}
}
IEnumerator StartCdCoroutine(AbilityButton button, float time)
{
button.cdFrame.gameObject.SetActive(true);
button.cdFrame.fillAmount = 1;
button.onCd = true;
while (true)
{
float timeProgress = button.cdFrame.fillAmount - Time.deltaTime / time;
if (timeProgress <= 0)
{
button.cdFrame.gameObject.SetActive(false);
button.onCd = false;
yield break;
}
else
{
button.cdFrame.fillAmount = timeProgress;
yield return(null);
}
}
}
public override void HandleInput(GameTime gameTime)
{
var mouseState = Mouse.GetState();
var keyboardState = Keyboard.GetState();
var deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
var mouseWorldLocation = scene.Unproject(mouseState);
FindMouseOverActor(mouseState, mouseWorldLocation);
var form = System.Windows.Forms.Form.FromHandle(ScreenManager.Game.Window.Handle);
if (isTargetting != null)
{
if (isTargetting.Ability.TargettingType == TargettingTypes.Location)
{
if (form.Cursor != System.Windows.Forms.Cursors.Cross)
form.Cursor = System.Windows.Forms.Cursors.Cross;
}
else if (mouseOverActor != null)
{
if ((isTargetting.Ability.TargettingType == TargettingTypes.Friendly && mouseOverActor.Faction != Factions.Friend) ||
(isTargetting.Ability.TargettingType == TargettingTypes.Hostile && mouseOverActor.Faction != Factions.Enemy))
{
if (form.Cursor != System.Windows.Forms.Cursors.No)
form.Cursor = System.Windows.Forms.Cursors.No;
}
else
{
if (form.Cursor != System.Windows.Forms.Cursors.Cross)
form.Cursor = System.Windows.Forms.Cursors.Cross;
}
}
else
{
if (form.Cursor != System.Windows.Forms.Cursors.SizeAll)
form.Cursor = System.Windows.Forms.Cursors.SizeAll;
}
}
else if (mouseOverActor != null)
{
if (form.Cursor != System.Windows.Forms.Cursors.Hand)
form.Cursor = System.Windows.Forms.Cursors.Hand;
}
else
{
if (form.Cursor != System.Windows.Forms.Cursors.Arrow)
form.Cursor = System.Windows.Forms.Cursors.Arrow;
}
if (mouseState.LeftButton == ButtonState.Pressed && !isPressingLeft || dragStart.HasValue)
{
isPressingLeft = true;
if (!Controls.Any(x => x.IsMouseOver))
{
if (isTargetting != null)
{
var ability = isTargetting.Ability;
var actor = isTargetting.Actor;
var target = mouseOverActor;
if (ability.TargettingType == TargettingTypes.Self)
IssueOrder(actor, new Order(ability, actor, actor));
else if (ability.TargettingType == TargettingTypes.Hostile && target != null && target.Faction != actor.Faction)
IssueOrder(actor, new Order(ability, actor, target));
else if (ability.TargettingType == TargettingTypes.Friendly && target != null && target.Faction == actor.Faction)
IssueOrder(actor, new Order(ability, actor, target));
else if (ability.TargettingType == TargettingTypes.Location)
IssueOrder(actor, new Order(ability, actor, null, mouseWorldLocation));
isTargetting = null;
}
else
{
if (keyboardState.IsKeyUp(Keys.LeftShift))
selectedActors.Clear();
if (mouseOverActor != null && !selectedActors.Contains(mouseOverActor))
selectedActors.Add(mouseOverActor);
if (dragStart.HasValue)
{
if (Math.Abs(mouseState.X - dragStart.Value.X) > 10 || Math.Abs(mouseState.Y - dragStart.Value.Y) > 10)
dragEnd = mouseState;
}
else
dragStart = mouseState;
if (dragStart.HasValue && dragEnd.HasValue)
{
var x1 = Math.Min(dragStart.Value.X, dragEnd.Value.X);
var x2 = Math.Max(dragStart.Value.X, dragEnd.Value.X);
var y1 = Math.Min(dragStart.Value.Y, dragEnd.Value.Y);
var y2 = Math.Max(dragStart.Value.Y, dragEnd.Value.Y);
selectedActors.Clear();
foreach (var actor in battle.Actors.Where(x => x.IsAlive && x.Faction == Factions.Friend))
{
var pos = scene.Project(actor.Position);
if (pos.X > x1 && pos.X < x2 && pos.Y > y1 && pos.Y < y2)
selectedActors.Add(actor);
}
}
}
}
else
{
isTargetting = null;
}
}
if (mouseState.LeftButton == ButtonState.Released)
{
isPressingLeft = false;
dragStart = null;
dragEnd = null;
}
if (mouseState.RightButton == ButtonState.Pressed && selectedActors.Any())
{
isTargetting = null;
if (mouseOverActor != null)
{
foreach (var actor in selectedActors)
{
if (keyboardState.IsKeyDown(Keys.LeftShift))
actor.QueueTargetActor(mouseOverActor);
else
actor.TargetActor(mouseOverActor);
}
}
else
{
foreach (var actor in selectedActors)
{
actor.OrderMoveTo(mouseWorldLocation);
}
}
}
if (keyboardState.IsKeyDown(Keys.Escape))
{
battle.Forfeit();
}
scene.HandleInput(gameTime);
}
private void abilityButton_Click(Button button)
{
if (button != null)
{
var abilityButton = button.Content as AbilityButton;
if (abilityButton != null)
{
var ability = abilityButton.Ability;
var actor = abilityButton.Actor;
if (ability.TargettingType == TargettingTypes.Self)
IssueOrder(actor, new Order(ability, actor, actor));
else
isTargetting = abilityButton;
}
}
}
public void ClickedButton (AbilityButton _button)
{
if (_button == currentSelection) {
if (_button.isSelected) {
this.currentSelection = null;
_button.isSelected = false;
_button.SetTint (normalTint);
}
} else {
if (currentSelection != null) {
currentSelection.isSelected = false;
currentSelection.SetTint (normalTint);
}
currentSelection = _button;
_button.isSelected = true;
_button.SetTint (selectedTint);
}
}
