void LoadCharacterData(PlayableCharacter character)
{
CharacterStats characterStats = character.charStats;
//Character base
avatarImage.sprite = characterStats.avatar;
EquipableItem weapon = character.currentEquipment.currentWeapon;
if (weapon != null)
{
charWeaponText.text = weapon.itemName;
}
else
{
charWeaponText.text = "";
}
EquipableItem armor = character.currentEquipment.currentArmor;
if (armor != null)
{
charArmorText.text = armor.itemName;
}
else
{
charArmorText.text = "";
}
//Character stats
currentAttackText.text = characterStats.totalAttack.ToString();
currentDefenseText.text = characterStats.totalDefense.ToString();
currentSpeedText.text = characterStats.totalSpeed.ToString();
currentMagicText.text = characterStats.totalMagic.ToString();
PrintUpdatedStats(characterStats);
}
public override void UseMagic(PlayableCharacter user, bool is_battle)
{
SpendMana(user);
Unit target = user.CurrentTarget;
Random rng = new Random();
Console.WriteLine($"{user.Name} is making a move!\n");
Console.WriteLine($"{user.Name} attempts to summon a powerful spell...");
SoundManager.magic_attack.SmartPlay();
CMethods.SmartSleep(750);
int attack_damage = UnitManager.CalculateDamage(user, target, CEnums.DamageType.magical, spell_power: SpellPower);
if (target.Evasion < rng.Next(0, 512))
{
SoundManager.enemy_hit.SmartPlay();
target.HP -= attack_damage;
Console.WriteLine($"{user.Name}'s attack connects with the {target.Name}, dealing {attack_damage} damage!");
}
else
{
SoundManager.attack_miss.SmartPlay();
Console.WriteLine($"The {target.Name} narrowly dodges {user.Name}'s spell!");
}
}
public override void UseMagic(PlayableCharacter user, bool is_battle)
{
SpendMana(user);
Unit target = user.CurrentTarget;
Console.WriteLine($"{user.Name} is making a move!\n");
Console.WriteLine($"{user.Name} is preparing to cast {SpellName}...");
SoundManager.ability_cast.SmartPlay();
CMethods.SmartSleep(750);
if (target == user)
{
Console.WriteLine($"{user.Name} raises their stats using the power of {SpellName}!");
}
else
{
Console.WriteLine($"{user.Name} raises {target.Name}'s stats using the power of {SpellName}!");
}
SoundManager.buff_spell.SmartPlay();
// We write to TempStats instead of the player's actual stats so that the changes will
// not persist after battle
target.TempStats[Stat] = (int)(target.TempStats[Stat] * (1 + IncreaseAmount));
}
public void BuildInitialPlayerDeck()
{
GameObject[] PlayersAlive = GameObject.FindGameObjectsWithTag("Player");
// Debug.Log (PlayersAlive.Length);
//Tekee alkupakat ensimmäiseen taisteluun.
//Nämä pakat ovat ennalta määritetyt
GameObject Scripts = GameObject.Find("_ScriptsTutorialBattle");
foreach (GameObject Player in PlayersAlive)
{
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
// Debug.Log (player.name);
if (player.PlayerClass.CharacterClassName == "Warrior")
{
WarriorStartDeck warriorStartDeck = Scripts.GetComponent <WarriorStartDeck> ();
warriorStartDeck.StartDeck();
}
else if (player.PlayerClass.CharacterClassName == "Mage")
{
MageStartDeck mageStartDeck = Scripts.GetComponent <MageStartDeck> ();
mageStartDeck.StartDeck();
}
else if (player.PlayerClass.CharacterClassName == "Priest")
{
PriestStartDeck priestStartDeck = Scripts.GetComponent <PriestStartDeck> ();
priestStartDeck.StartDeck();
}
else if (player.PlayerClass.CharacterClassName == "Rogue")
{
RogueStartDeck rogueStartDeck = Scripts.GetComponent <RogueStartDeck> ();
rogueStartDeck.StartDeck();
}
}
}
public void SelectedPlayerThree()
{
GameObject Player = GameObject.Find("Player3");
PlayableCharacter player = Player.GetComponent <PlayableCharacter>();
selecterModifyPlayer = player;
}
private void CalculateDistancesToPlayers()
{
int minDistance = 30;
Vector3 startLoc = new Vector3();
Vector3 endLoc = new Vector3();
startLoc.y = TileY;
startLoc.z = TileX - (TileY - (Mathf.Abs(TileY) % 2)) / 2;
startLoc.x = -startLoc.y - startLoc.z;
GameObject[] Players = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject Player in Players)
{
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
endLoc.y = player.PlayerClass.TileY;
endLoc.z = player.PlayerClass.TileX - (player.PlayerClass.TileY - (Mathf.Abs(player.PlayerClass.TileY) % 2)) / 2;
endLoc.x = -endLoc.y - endLoc.z;
int d = (int)(Mathf.Abs(startLoc.x - endLoc.x) + Mathf.Abs(startLoc.y - endLoc.y) + Mathf.Abs(startLoc.z - endLoc.z)) / 2;
player.PlayerClass.DistanceToEnemy = d;
if (d <= minDistance)
{
minDistance = d;
}
}
foreach (GameObject Player in Players)
{
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
if (player.PlayerClass.DistanceToEnemy == minDistance)
{
selectedPlayer = player.name;
return;
}
}
}
public virtual void Fix()
{
// If the sabotagable is fully fixed
isSabotaged = false;
// Tell everyone that the task is now completed
task.CompleteRPC(false);
task = null;
Destroy(GetComponent <Task>());
DisableTaskMarker();
// Update UI and animation
sabotageManager.SabotageFixed();
animationObject.SetActive(false);
// Reset sabotage/task idicators
PlayableCharacter me = NetworkManager.instance.GetMe();
if (inRange && me is Traitor)
{
EnableSabotageMarker();
}
else if (me is Loyal)
{
me.EnableTaskMarker();
}
// After an item is fixed its no longer interactable for anyone, as
// they are single use
Destroy(this);
}
public async Task Load(params string[] s)
{
string name = string.Join(" ", s);
if (string.IsNullOrEmpty(name))
{
var characterString = "```yaml" + Environment.NewLine + "\u200b";
var animaChars = CharacterRepository.Characters.OfType <AnimaCharacter>().Where(x => x.Player == Context.Message.Author.Mention);
if (animaChars.Any())
{
characterString += "Anima:" + Environment.NewLine;
foreach (AnimaCharacter character in animaChars)
{
characterString += " " + character.Name + " - LVL " + character.Level + (character.IsCurrent ? " (loaded)" : "") + Environment.NewLine;
}
}
var lChars = CharacterRepository.Characters.OfType <L5RCharacter>().Where(x => x.Player == Context.Message.Author.Mention);
if (lChars.Any())
{
characterString += "Legend of the five Rings:" + Environment.NewLine;
foreach (var character in lChars)
{
characterString += " " + character.Name + " - " + character.Clan + (character.IsCurrent ? " (loaded)" : "") + Environment.NewLine;
}
}
characterString += "```";
await Context.Message.DeleteAsync();
await Context.Channel.SendMessageAsync("List of playable characters :" + Environment.NewLine + characterString);
}
else
{
PlayableCharacter character = null;
try
{
CharacterRepository.Characters.Where(x => x.Player == Context.Message.Author.Mention).ToList().ForEach(x => x.IsCurrent = false);
character = CharacterRepository.Find <PlayableCharacter>(Context.Message.Author.Mention, name);
character.IsCurrent = true;
//await (Context.Message.Author as IGuildUser).ModifyAsync(x => x.Nickname = character.Name);
}
catch (InvalidOperationException ex)
{
await Context.Channel.SendMessageAsync("Error 404: Character not found!");
throw;
}
//catch (Exception)
//{
// await Context.Channel.SendMessageAsync("Nickname could not be changed for " + Context.Message.Author.Mention);
//}
await Context.Message.DeleteAsync();
await Context.Channel.SendMessageAsync($"Character : {character.Name} successfully loaded !");
}
}
private void Awake()
{
learntSkills = new List <Skill>();
unknownSkills = new List <Skill>();
m_owner = GetComponent <PlayableCharacter>();
}
public async Task DeleteCharacter(params string[] s)
{
_ = Context.Message.DeleteAsync();
string expr = string.Join(' ', s);
PlayableCharacter character = CharacterRepository.Find <PlayableCharacter>(Context.Message.Author.Mention, expr);
if (character == null)
{
await Context.Channel.SendMessageAsync("Error 404: Character not found or currently loaded!");
return;
}
try
{
CharacterRepository.DeleteExcelCharacter(character);
}
catch (Exception ex)
{
await Context.Channel.SendMessageAsync($"Erreur lors de la suppression du fichier.{Environment.NewLine}{ex.Message}");
throw;
}
await Context.Channel.SendMessageAsync("Suppression effectuée.");
}
public void SetRider(PlayableCharacter PC)
{
Rigidbody2D RBody = GetComponent <Rigidbody2D>();
if (Rider != null)
{
Rider.transform.parent = null;
Rider.transform.position = Ground.position;
Collider2D col = Rider.GetComponent <Collider2D>();
col.enabled = true;
Controller.SetTarget(Rider);
CharacterConfiguration.Alignment = 0;
RBody.constraints = RigidbodyConstraints2D.FreezeAll;
}
Rider = PC;
if (PC != null)
{
PC.transform.position = Saddle.position;
PC.transform.parent = transform;
PC.Controller.SetTarget(this);
CharacterConfiguration.Alignment = PC.CharacterConfiguration.Alignment;
Collider2D col = PC.GetComponent <Collider2D>();
RBody.constraints = RigidbodyConstraints2D.FreezeRotation;
col.enabled = false;
return;
}
}
public void Interact(PlayableCharacter PC)
{
if (CanInteract)
{
SetRider(PC);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (!isServer)//only server version deals damage
{
return;
}
if (tag.Equals("Enemy"))
{
return;
}
//Debug.Log("touched plyer"+timeBtwLeft);
if (other.CompareTag("PlayerObject") && isDead == false)
{
if (timeBtwLeft <= 0)
{
PlayableCharacter PC = other.GetComponent <PlayableCharacter>();
if (PC) //collided with player deal damage
{
timeBtwLeft = timeBtwDamage;
PC.RD.TakeDamage(damage);
//Debug.Log("boss touched player dealing damage");
}
}
}
}
public void SetVote(Vote vote, int votingPlayerId)
{
// -1 as player being voted on does not vote
int numberOfVotingPlayers = NetworkManager.instance.GetPlayers().Count - 1;
// Get the player who is voting
PlayableCharacter votingPlayer = PhotonView.Find(votingPlayerId).GetComponent <PlayableCharacter>();
// Add player to correct player list
if (vote == Vote.For)
{
playersVotingFor.Add(votingPlayer);
}
if (vote == Vote.Against)
{
playersVotingAgainst.Add(votingPlayer);
}
// Set UI
playersUI.SetPlayerVote(vote, votingPlayer);
votesFor.text = $"For: {playersVotingFor.Count}";
votesAgainst.text = $"Against: {playersVotingAgainst.Count}";
// Check if the vote should now be ended
if (playersVotingFor.Count > numberOfVotingPlayers / 2 || playersVotingAgainst.Count >= numberOfVotingPlayers / 2)
{
EndVote();
}
}
public void StartVote(int suspectedPlayerId, int voteLeaderId)
{
voteStarted = true;
hasVoted = false;
// Empty list of whos voted for what
playersVotingFor = new List <PlayableCharacter>();
playersVotingAgainst = new List <PlayableCharacter>();
// Set the voting players
suspectedPlayer = PhotonView.Find(suspectedPlayerId).GetComponent <PlayableCharacter>();
playersUI.SetSuspectedPlayer(suspectedPlayer);
voteLeader = PhotonView.Find(voteLeaderId).GetComponent <PlayableCharacter>();
// UI
voteTopRightUI.SetActive(true);
currentVoteUI.SetActive(true);
votesFor.text = $"For: 0";
votesAgainst.text = $"Against: 0";
// Check if the vote is on you
bool voteIsOnYou = NetworkManager.instance.GetMe() == suspectedPlayer;
// At set text of UI based on if you are being voted on or not
votingUIText.text = voteIsOnYou ? "You are being voted on!": $"Is {suspectedPlayer.Owner.NickName} the traitor?";
helperText.text = voteIsOnYou ? "Convince everyone you're not the traitor" : "Press 'Y' for yes, 'N' for no.";
setVoteUI.SetActive(true);
// Start voting music
votingMusic.Play();
}
void CreateMessage()
{
MessageDialog msg1 = new MessageDialog();
PlayableCharacter char1 = CharacterParty.charactersParty.Find(p => p.charStats.name.Equals(charName));
msg1.avatarImage = char1.charStats.avatar;
msg1.avatarName = char1.charStats.name;
msg1.dialogText = quote;
msgList.Add(msg1);
MessageDialog msg2 = new MessageDialog();
msg2.avatarImage = msg1.avatarImage;
msg2.avatarName = msg1.avatarName;
msg2.dialogText = quote2;
msgList.Add(msg2);
MessageDialog msg3 = new MessageDialog();
msg3.dialogText = quote3;
msgList.Add(msg3);
MessageDialog msg4 = new MessageDialog();
msg4.avatarImage = char1.charStats.avatar;
msg4.avatarName = char1.charStats.name;
msg4.dialogText = quote4;
msgList.Add(msg4);
}
public static void UpdateCharacter(PlayableCharacter player)
{
int index = charactersParty.FindIndex(p => p.charStats.name.Equals(player.charStats.name));
charactersParty.RemoveAt(index);
charactersParty.Insert(index, player);
}
// void OnTriggerEnter2D(Collider2D other)
// {
// PlayableCharacter playableCharacter_temp = other.GetComponent<PlayableCharacter>();
// if (playableCharacter_temp && ApplicableCharacters.Contains(playableCharacter_temp.PlayerType))
// {
// buttonInstance.SetActive(true);
// PatternButtonAnim.SetTrigger(MiniGame.ButtonAnimations[XboxButton.A]);
//// if (CharPos)
//// {
//// playableCharacter.disableMovement();
//// playableCharacter.transform.position = CharPos.position;
//// playableCharacter.PlayerController.isRight = CharFacingRight;
//// }
//// MiniGameScript.StartMiniGame(this, playableCharacter);
// }
// }
private void OnTriggerStay2D(Collider2D other)
{
if (MiniGameScript.inMiniGame || (_brokenMiniGame.CanBeBroke && _brokenMiniGame.BrokenMiniGameScript.inMiniGame))
{
return;
}
PlayableCharacter playableCharacter_temp = other.GetComponent <PlayableCharacter>();
if (!playableCharacter_temp)
{
return;
}
if (!IsBroken)
{
if (state == State.READY && ApplicableCharacters.Contains(playableCharacter_temp.PlayerType))
{
currentMiniGameInPlay = MiniGameScript;
EnterMiniGame(currentMiniGameInPlay, playableCharacter_temp);
}
}
else
{
if (playableCharacter_temp.PlayerType == GameManager.PlayerType.Dad)
{
currentMiniGameInPlay = _brokenMiniGame.BrokenMiniGameScript;
EnterMiniGame(currentMiniGameInPlay, playableCharacter_temp);
}
}
}
public void SetHealthBarPlayer()
{
// Debug.Log("Healthbar test");
float myHealth = CurHealth / maxHealth;
// Debug.Log(curHealth + " current Health");
// Debug.Log(myHealth);
if (myHealth <= 0)
{
myHealth = 0;
}
if (myHealth >= 1)
{
myHealth = 1;
}
healthBar.transform.localScale = new Vector3(myHealth, healthBar.transform.localScale.y, healthBar.transform.localScale.z);
// Debug.Log("myHealth " + myHealth);
GameObject TileMap = GameObject.Find("Map");
TileMap map = TileMap.GetComponent <TileMap>();
GameObject Enemy = GameObject.Find(map.selectedEnemy);
BaseEnemy enemy = Enemy.GetComponent <BaseEnemy>();
GameObject Player = GameObject.Find(enemy.selectedPlayer);
PlayableCharacter player = Player.GetComponent <PlayableCharacter>();
player.PlayerClass.HpPointsRemaining = (int)(myHealth * player.PlayerClass.HpPointsMax);
}
public override void OnEnter()
{
character = GetComponentInParent <PlayableCharacter>();
nextState = "";
character.boxCollider.enabled = false;
character.aiPath.canMove = false;
}
public void CalculateDistanceToTargets(int startPointX, int startPointY)
{
Vector3 startLoc = new Vector3();
Vector3 endLoc = new Vector3();
startLoc.y = startPointY;
startLoc.z = startPointX - (startPointY - (Mathf.Abs(startPointY) % 2)) / 2;
startLoc.x = -startLoc.y - startLoc.z;
GameObject[] PlayersAlive = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject Player in PlayersAlive)
{
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
endLoc.y = player.PlayerClass.TileY;
endLoc.z = player.PlayerClass.TileX - (player.PlayerClass.TileY - (Mathf.Abs(player.PlayerClass.TileY) % 2)) / 2;
endLoc.x = -endLoc.y - endLoc.z;
int distance = (int)(Mathf.Abs(startLoc.x - endLoc.x) + Mathf.Abs(startLoc.y - endLoc.y) + Mathf.Abs(startLoc.z - endLoc.z)) / 2;
if (distance <= range)
{
GameObject Tile = GameObject.Find("Hex_" + player.PlayerClass.TileX + "_" + player.PlayerClass.TileY);
ClickableTile tile = Tile.GetComponent <ClickableTile> ();
GameObject HighlightTiles = GameObject.Find("_Scripts");
HighlightTiles highlightTiles = HighlightTiles.GetComponent <HighlightTiles> ();
highlightTiles.tileX = tile.tileX;
highlightTiles.tileY = tile.tileY;
highlightTiles.ShowHoveringTileSkill();
}
}
}
public void UpdateHand()
{
// GameObject Map = GameObject.Find("Map");
// TileMap map = Map.GetComponent<TileMap> ();
GameObject Player = GameObject.Find(map.selecterPlayer);
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
GameObject Hand = GameObject.Find("Hand");
DamageCard[] HealCards = Hand.GetComponentsInChildren <DamageCard> ();
foreach (DamageCard card in HealCards)
{
int cardDamage = 0;
int cardCost = Mathf.CeilToInt(card.CardCost * (1 - player.PlayerClass.CardCostReduction));
switch (card.DamageType)
{
case DamageTypes.Physical:
cardDamage = card.CardDamage * player.PlayerClass.PhysicalAttackDMG;
break;
case DamageTypes.Magic:
cardDamage = card.CardDamage * player.PlayerClass.MagicAttackDMG;
break;
case DamageTypes.Ranged:
cardDamage = card.CardDamage * player.PlayerClass.RangedAttackDMG;
break;
default:
break;
}
card.transform.Find("CardAttack").GetComponent <Text>().text = cardDamage.ToString();
card.transform.Find("CardCost").GetComponent <Text>().text = cardCost.ToString();
}
}
void Update()
{
// If all players are in the scene and spawned then assign tasks
if (PhotonNetwork.LocalPlayer.IsMasterClient &&
NetworkManager.instance.CheckAllPlayers <string>("CurrentScene", "GameScene") &&
NetworkManager.instance.AllCharactersSpawned() &&
!NetworkManager.instance.RoomPropertyIs <bool>("TasksSet", true)
)
{
SetTasks();
}
// Set inital task for player
if (
!requested &&
NetworkManager.instance.RoomPropertyIs("TasksSet", true)
)
{
requested = true;
PlayableCharacter character = NetworkManager.instance.GetMe();
if (character is Loyal)
{
Debug.Log("Requesting new task!");
RequestNewTask();
}
}
}
public virtual void StartMiniGame(ActionableObject actionable, PlayableCharacter initiator)
{
inMiniGame = true;
print("Start parent game");
actionableObject = actionable;
player = initiator;
isPlaying = true;
player.currentMiniGame = this;
if (!objectAnimationEnter.Equals("") && !objectAnimationEntered)
{
objectAnimationEntered = true;
_animator.SetTrigger(objectAnimationEnter);
}
if (!playerAnimationEnter.Equals("") && !playerAnimationEntered)
{
playerAnimationEntered = true;
player.m_animator.SetTrigger(playerAnimationEnter);
}
if (desapireInEnter)
{
player.enabledMovement(false);
player.spriteRenderer.enabled = false;
}
}
private void CreateMagicButtons()
{
PlayableCharacter currentChar = HeroesToManage[0].GetComponent <CharacterStateMachine>().GetCharacter();
List <BaseAttack> magicAttacksList = currentChar.magicAttacks;
int CharMana = currentChar.charStats.currentMagicPoints;
if (magicAttacksList.Count > 0)
{
Button magicButton = CreateButton(m_LanguageManagerInstance.GetTextValue(m_MagicTextKey));
magicButton.onClick.AddListener(() => SwitchToMagicAttacks());
foreach (BaseAttack magicAttack in magicAttacksList)
{
Button magButton = CreateButton(magicAttacksButton, m_LanguageManagerInstance.GetTextValue(magicAttack.attackName), magicSpacer, false);
AttackButton attButton = magButton.transform.parent.GetComponent <AttackButton>();
attButton.magicAttackToPerform = magicAttack;
magicButtonsList.Add(magButton);
//Controla si se puede realizar la magia
if (magicAttack.attackCost > CharMana)
{
attButton.DeactivateButton();
}
else if (attButton.IsDeactivated())
{
attButton.ActivateButton();
}
}
}
}
public IEnumerator SabotageStarted(Sabotageable sabotageable)
{
this.sabotageable = sabotageable;
StartCoroutine(NotifySabotage());
// Wait till sabotage starts
yield return(new WaitForSeconds(5));
// Start sabotage timer
timerManager.StartTimer(Timer.sabotageTimer);
// Play music
sabotageMusic.Play();
// Update UI
sabotageMiddleUI.SetActive(true);
taskUI.SetActive(false);
taskNotificationUI.SetActive(false);
warningText.gameObject.SetActive(true);
sabotageUI.SetActive(true);
// Set task marker
PlayableCharacter me = NetworkManager.instance.GetMe();
if (me is Loyal)
{
me.DisableTaskMarker();
}
yield return(new WaitForSeconds(7));
warningText.gameObject.SetActive(false);
}
private void LoadCharacter(int characterIndex, Transform objectTransform)
{
PlayableCharacter playCharacter = CharacterParty.charactersParty[characterIndex];
GameObject characterGO = Instantiate(playCharacter.prefab);
characterGO.transform.position = objectTransform.position;
characterGO.transform.rotation = objectTransform.rotation;
PlayableCharacter character = characterGO.GetComponent <PlayableCharacter>();
character.charStats = playCharacter.charStats;
character.currentEquipment = playCharacter.currentEquipment;
character.magicAttacks = playCharacter.magicAttacks;
character.attacksList = playCharacter.attacksList;
GameObject charStatsPanel = Instantiate(characterBattleStatsPrefab, characterBattleStatsPanel, false);
CharacterStateMachine stateMachine = characterGO.GetComponent <CharacterStateMachine>();
CharacterSelected button = charStatsPanel.GetComponentInChildren <CharacterSelected>();
button.characterPrefab = characterGO;
Transform stateMachineTransform = charStatsPanel.transform.Find(progressBarName);
stateMachine.progressBar = stateMachineTransform.GetComponent <Image>();
stateMachine.nameText = charStatsPanel.transform.Find(nameTextName).GetComponent <Text>();
stateMachine.healthText = charStatsPanel.transform.Find(HPTextName).GetComponent <Text>();
stateMachine.magicText = charStatsPanel.transform.Find(MPTextName).GetComponent <Text>();
charatersList.Add(playCharacter);
HeroesInBattle.Add(characterGO);
}
public void SetCharacter(int playerNumber, PlayableCharacter character)
{
if (!pControlInfo[playerNumber].character)
{
pControlInfo[playerNumber].character = character;
}
}
IEnumerator EndGameScreen(PlayableCharacter winner)
{
Controls.controlsEnabled = false;
GameObject endGameUI = GameObject.Find("EndScreens");
endGameUI.GetComponent<Image>().enabled = true;
Text endText = endGameUI.transform.FindChild("EndText").GetComponent<Text>();
if (winner is Bear)
{
endGameUI.transform.FindChild("EndBear").GetComponent<Image>().enabled = true;
_audioSource.PlayOneShot(bearWinSound);
endText.color = new Color(1f, 200f / 255f, 41f / 255f);
endText.text = "Bear won !";
}
else if (winner is Eagle)
{
endGameUI.transform.FindChild("EndEagle").GetComponent<Image>().enabled = true;
_audioSource.PlayOneShot(eagleWinSound);
endText.color = new Color(0f, 227f / 255f, 20f / 255f);
endText.text = "Eagle won !";
}
else
{
endGameUI.transform.FindChild("EndPig").GetComponent<Image>().enabled = true;
_audioSource.PlayOneShot(pigWinSound);
endText.color = new Color(182f / 255f, 87f / 255f, 161f / 255f);
endText.text = "Pig won !";
}
endText.enabled = true;
yield return new WaitForSeconds(4f);
Controls.controlsEnabled = true;
Application.LoadLevel(0);
}
// Calls RPC to assing task to character and also call the funciton that the
// rpc reference to ensure task is completed instanly on master client
public void AssignTask(PlayableCharacter character)
{
//Master calls assignToCharacter first to ensure it is done before anyone else
AssignTaskToCharacter(character);
//Then we call AssignToCharacter on all other players
View.RPC("AssignTaskToCharacterRPC", RpcTarget.Others, character.View.ViewID);
}
public void CheckVisibleTiles()
{
GameObject DrawLine = GameObject.Find("LineRenderer");
DrawLine drawLine = DrawLine.GetComponent <DrawLine> ();
visibleTiles = new List <Node>();
drawLine.skillDistance = 20;
GameObject Player = GameObject.Find(selecterPlayer);
PlayableCharacter player = Player.GetComponent <PlayableCharacter> ();
// player.VisibleNodes = null;
GameObject[] Tiles = GameObject.FindGameObjectsWithTag("Hex");
foreach (GameObject tile in Tiles)
{
ClickableTile clickableTile = tile.GetComponent <ClickableTile> ();
bool allowed = drawLine.CalculateLine(player.PlayerClass.TileX, player.PlayerClass.TileY, clickableTile.tileX, clickableTile.tileY);
if (allowed)
{
// clickableTile.hexVisible = true;
visibleTiles.Add(graph[clickableTile.tileX, clickableTile.tileY]);
}
else
{
// clickableTile.hexVisible = false;
}
}
player.VisibleNodes = visibleTiles;
}
public void EndGame(PlayableCharacter winner)
{
_endGame = true;
StartCoroutine(EndGameScreen(winner));
}
public void ReloadCharacterStats(PlayableCharacter character)
{
int hp = character.GetModifiedStatValue("HP");
int maxHP = character.GetModifiedStatValue("Max HP");
HealthLabel.Text = string.Format("{0}/{1}", hp, maxHP);
MagicLabel.Text = character.GetModifiedStatValue("Magic").ToString();
AttackLabel.Text = character.GetModifiedStatValue("Attack").ToString();
MaxAtbLabel.Text = character.GetModifiedStatValue("Max ATB").ToString();
AtbSpeedLabel.Text = character.GetModifiedStatValue("ATB Speed").ToString();
}
public void UpdateMemberName(PlayableCharacter character)
{
MemberNameLabel.Text = character.Name;
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
graphics.PreferredBackBufferWidth = graphics.GraphicsDevice.DisplayMode.Width;
graphics.PreferredBackBufferHeight = graphics.GraphicsDevice.DisplayMode.Height;
graphics.ApplyChanges();
//Engine.LevelBounds = new Rectangle(0, 0, graphics.GraphicsDevice.Viewport.Width * 2, graphics.GraphicsDevice.Viewport.Height);
base.Initialize();
Engine.InitializeLevel("Level1");
player = Engine.InitializePlayer();
Engine.InitializeEnemies();
Engine.InitializeObjects();
Engine.InitializeUpdatableObjects();
Engine.InitializeItems();
camera = new Camera2D(graphics.GraphicsDevice);
camera.SetSceneBounds(new Rectangle(50, 50, Engine.LevelBounds.Width - 200, Engine.LevelBounds.Height));
camera.SetChaseTarget(player);
debug = new MidoriDebug(Content, spriteBatch);
gameOver = false;
player.PlayerIsDead += (sender, evArgs) => { gameOver = true; };
}
public void ReloadCharacterEquipment(PlayableCharacter character)
{
ReloadWeaponStats(character.Weapon);
ReloadArmorStats(character.Armor);
ReloadAccessoryStats(character.Accessory);
}
