public void NextTurn()
{
currentBoardEntity = null;
boardEntitySelector.setSelectedBoardEntity(null);
if (!endState)
{
ReCalcQueue();
PathOnClick.pause = true;
tileSelectionManager.CancelSelection();
CharacterBoardEntity tempcurrentBoardEntity = turnQueue[0];
alreadyTakenTurn.Add(tempcurrentBoardEntity);
turnQueue.RemoveAt(0);
CenterText.Instance.DisplayMessage(tempcurrentBoardEntity.Name + "'s Turn", () =>
{
currentBoardEntity = tempcurrentBoardEntity;
SetCurrentTurnMarker((CharacterBoardEntity)tempcurrentBoardEntity);
PathOnClick.pause = false;
UpdateGui();
((CharacterBoardEntity)tempcurrentBoardEntity).SetUpMyTurn();
if (currentBoardEntity.Team == Team.Player)
{
boardEntitySelector.setSelectedBoardEntity(currentBoardEntity);
}
tempcurrentBoardEntity.StartMyTurn();
});
}
}
private void DisplayCharacter(CharacterBoardEntity character, Ka ka)
{
characterView.DisplayCharacter(character);
if (ka != null)
{
characterView.DisplayKa(ScenePropertyManager.Instance.TypeToBE[ka.CharacterType]);
}
}
private void SetCurrentTurnMarker(CharacterBoardEntity characterBoardEntity)
{
if (characterBoardEntity != null)
{
currentTurnPointer.GetComponent <UIFollow>().target = characterBoardEntity.gameObject;
currentTurnPointer.SetActive(true);
}
}
public void SetSelectedKa(CharacterBoardEntity character)
{
ClearParty((int)ColorLocks.secondary);
if (character != null)
{
kaToButton[character].GetComponent <ColorEffectManager>().TurnOn((int)ColorLocks.secondary, Color.red);
}
}
public void ExecuteTurn(CharacterBoardEntity character, Action callBack, BoardEntity ragedBy = null)
{
this.callBack = callBack;
this.character = character;
this.ragedBy = ragedBy;
counter = 0;
CheckIfDone();
}
private GameObject MakeCharacter(CharacterBoardEntity character, Position position, Ka ka = null)
{
GameObject characterObj = character.gameObject;
GameObject BE = Instantiate(characterObj);
BE.GetComponent <CharacterBoardEntity>().Init(position, turnManager, tileManager, boardEntitySelector, battleCalulator, ka);
return(BE);
}
public virtual void TileEnter(CharacterBoardEntity character, Tile t)
{
if (enterAction != null)
{
if (enterAction(t, character))
{
Remove();
}
}
}
public void DisplayCharacter(CharacterBoardEntity character, bool moveArrow = true)
{
selectedCharacter = character;
profileDisplay.SetActive(false);
helpButton.SetActive(false);
profileHidden.SetActive(true);
addToParty.interactable = false;
DisplayKa(null);
characterSelection2.SetSelectedCharacter(character, moveArrow);
}
public void HighLightKaSelection(CharacterBoardEntity character)
{
foreach (KeyValuePair <CharacterBoardEntity, GameObject> thing in kaToButton)
{
if (thing.Key != character)
{
thing.Value.GetComponent <ColorEffectManager>().TurnOn((int)ColorLocks.secondary, Color.red);
}
}
}
private GameObject MakeButton(CharacterBoardEntity character)
{
GameObject buttonInstance = Instantiate(charButton);
charToButton.Add(character, buttonInstance);
buttonInstance.GetComponentInChildren <ProfileButton>().SetImage(character.ProfileImage);
buttonInstance.GetComponent <OnPointerDownListener>().pressed += () => SelectCharacter(character);
buttonInstance.transform.SetParent(characterSelectionContainer.transform, false);
return(buttonInstance);
}
public void Start()
{
characterSelection2.Init();
foreach (GameObject character in ScenePropertyManager.Instance.BoardEntityCharacters.Values)
{
selectedCharacter = character.GetComponent <CharacterBoardEntity>();
//DisplayCharacter(character.GetComponent<CharacterBoardEntity>(), true, false);
break;
}
}
public override void AboutToExecuteAction(Skill skill, List <Tile> tiles)
{
if (skill is BasicAttack)
{
CharacterBoardEntity character = tileManager.GetFirstCharacter(tiles);
if (character.HasPassiveType(PassiveType.Debuff))
{
Trigger();
}
}
}
public void DisplayKa(CharacterBoardEntity character)
{
if (character != null)
{
Ka ka = new Ka(character.GetComponent <CharContainer>());
DisplayKaHelper(ka);
}
else
{
DisplayKaHelper(null);
}
}
private void RemakeKaButtons()
{
ClearKaButtons();
CharacterBoardEntity selectedCharacter = characterView.GetSelectedCharacter();
foreach (GameObject character in ScenePropertyManager.Instance.BoardEntityCharacters.Values)
{
bool blank = selectedCharacter == character.GetComponent <CharacterBoardEntity>();
MakeKaButton(character.GetComponent <CharacterBoardEntity>(), blank);
}
GreyOutUsedCharacters();
}
public void Init(CharacterBoardEntity character)
{
this.character = character;
foreach (Passive passive in passives)
{
character.InitPassive(passive);
}
foreach (Skill skill in Skills)
{
character.InitSkill(skill);
}
}
public void QuickDamage(CharacterBoardEntity target, List <DamagePackage> damages)
{
foreach (DamagePackage package in damages)
{
SkillReport report = new SkillReport();
int health = HealthAfterDamage(report, target.Stats, package);
Stats afterStats = target.Stats.GetCopy();
afterStats.SetMutableStat(StatType.Health, health);
report.targets.Add(new Tuple <Stats, Stats>(target.Stats.GetCopy(), afterStats));
ExecuteSkillReport(report);
}
turnManager.CheckEntitiesForDeath();
}
/// I should really consolidate this code to profile.cs
public void SetProfilePic(CharacterBoardEntity prim, CharacterBoardEntity ka)
{
profileImage.sprite = prim.ProfileImage;
if (ka != null)
{
kaProfile.SetActive(true);
kaProfile.GetComponent <Image>().sprite = ka.ProfileImageCircle;
}
else
{
kaProfile.SetActive(false);
}
processBoardEntity(prim);
}
private void RemoveCharacter(CharacterBoardEntity character)
{
List <Tuple <CharacterBoardEntity, Ka> > party = ScenePropertyManager.Instance.GetCharacterParty();
for (int a = 0; a < party.Count; a++)
{
if (party[a].first == character)
{
party.RemoveAt(a);
break;
}
}
ScenePropertyManager.Instance.SetCharacterParty(party);
}
private bool EnterTile(Tile t, CharacterBoardEntity character)
{
if (character.Team == OtherTeam())
{
character.Stats.SetMutableStat(AttributeStats.StatType.Movement, 0);
battleCalculator.QuickDamage(character, new List <DamagePackage>()
{
new DamagePackage(3, DamageType.pure)
});
//character.AddPassive(new BuffBleed(2));
//character.InteruptMovment();
return(true);
}
return(false);
}
public void SetSelectedCharacter(CharacterBoardEntity character, bool moveArrow = true)
{
RemakeKaButtons();
ClearParty((int)ColorLocks.primary);
if (character != null)
{
charToButton[character].GetComponent <ColorEffectManager>().TurnOn((int)ColorLocks.primary, Color.yellow);
if (moveArrow && arrow != null)
{
arrow.SetActive(true);
//arrow.transform.position = new Vector3(110, charToButton[character].GetComponent<RectTransform>().position.y, 0);
//ugh this is gross
arrow.GetComponent <RectTransform>().anchoredPosition = new Vector3(100,
charToButton[character].GetComponent <RectTransform>().localPosition.y *
charToButton[character].GetComponent <RectTransform>().localScale.y, 0);
}
}
}
public void SetFirst(List <CharacterBoardEntity> list)
{
for (int a = 0; a < list.Count; a++)
{
CharacterBoardEntity b = list[a];
bool first = false;
foreach (Passive p in b.Passives)
{
first = p.TurnOrderFirst(first);
}
if (first)
{
list.Remove(b);
list.Insert(0, b);
}
}
}
private void ChargeCallback(Action callback, int distance, CharacterBoardEntity characterBoardEntity)
{
if (characterBoardEntity != null)
{
boardEntity.BasicAttack.Action(new List <Tile> {
characterBoardEntity.GetTile()
}, callback, free: true,
mods: new List <SkillModifier> {
new SkillModifier(SkillModifierType.Power, SkillModifierApplication.Add, distance)
});
}
else
{
if (callback != null)
{
callback();
}
}
}
private GameObject MakeKaButton(CharacterBoardEntity character, bool blank = false)
{
GameObject buttonInstance = Instantiate(charButton);
kaToButton.Add(character, buttonInstance);
buttonInstance.GetComponent <OnPointerDownListener>().pressed += () => SelectKa(character);
if (blank)
{
buttonInstance.GetComponentInChildren <ProfileButton>().SetImage(noneSprite);
buttonInstance.GetComponent <OnPointerDownListener>().OnPointerDown(null);
}
else
{
buttonInstance.GetComponentInChildren <ProfileButton>().SetImage(character.ProfileImage);
}
buttonInstance.transform.SetParent(kaSelectionContainer.transform, false);
return(buttonInstance);
}
public void Init(CharacterBoardEntity character, Action selected)
{
this.dropDown.value = 0;
this.selected = selected;
ClearDisplay();
if (character != null)
{
parent.GetComponent <Image>().color = Color.white;
gameObject.SetActive(true);
ka = new Ka(character.GetComponent <CharContainer>());
GenerateOptions(character);
}
else
{
parent.GetComponent <Image>().color = greyOut;
gameObject.SetActive(false);
ka = null;
}
}
private void DisplayKaHelper(Ka ka)
{
if (ka != null)
{
selectedKaCharacter = ScenePropertyManager.Instance.BoardEntityCharacters[ka.CharacterType].GetComponent <CharacterBoardEntity>();
characterSelection2.SetSelectedKa(selectedKaCharacter);
if (selectedKaCharacter == selectedCharacter)
{
selectedKaCharacter = null;
}
foreach (Profile2 profile in profiles)
{
profile.gameObject.SetActive(true);
profile.SetProfilePic(selectedCharacter, selectedKaCharacter);
}
DisplayHelper();
kaSkillSelect.Init(selectedKaCharacter, EnableAddToParty);
profileDisplay.SetActive(true);
helpButton.SetActive(true);
profileHidden.SetActive(false);
if (selectedKaCharacter != null)
{
addToParty.interactable = false;
addToPartyText.text = "Select a support skill";
}
else
{
EnableAddToParty();
}
}
else
{
selectedKaCharacter = null;
foreach (Profile2 profile in profiles)
{
profile.gameObject.SetActive(false);
}
}
//characterSelection2.SetSelectedKa(selectedKaCharacter);
}
public SkillReport ExecuteSkillHealing(Skill skill, CharacterBoardEntity source, CharacterBoardEntity target, int value)
{
SkillReport report = new SkillReport();
report.targetBefore = target.Stats.GetCopy();
report.targetAfter = target.Stats.GetCopy();
report.targetAfter.SetMutableStat(StatType.Health, report.targetAfter.GetMutableStat(StatType.Health).Value + value);
report.targets.Add(new Tuple <Stats, Stats>(report.targetBefore, report.targetAfter));
int healValue = report.targetAfter.GetMutableStat(StatType.Health).Value - report.targetBefore.GetMutableStat(StatType.Health).Value;
report.TextDisplays.Add(new TextDisplay()
{
text = "+ " + healValue,
textColor = Color.green,
callback = (() => target.SetAnimation(Common.Animator.AnimatorUtils.animationType.win)),
target = target
});
return(report);
}
public BuffTaunt(CharacterBoardEntity tauntedBy) : base()
{
type = PassiveType.Debuff;
this.tauntedBy = tauntedBy;
description = "can only move adjacent to " + tauntedBy.Name;
}
public override CharacterBoardEntity GetRagedBy(CharacterBoardEntity characterBoardEntity)
{
return(ragedBy);
}
public BuffRaged(CharacterBoardEntity ragedBy, int stacks = 1) : base(stacks)
{
type = PassiveType.Debuff;
this.ragedBy = ragedBy;
description = "Raged by " + ragedBy.Name;
}
public void PartialInit(CharacterBoardEntity boardEntity)
{
this.boardEntity = boardEntity;
}
