public void InstantiateEnemyByNetwork(string enemyId, int tileKey, Enemy.EnemyType type)
{
Tile startTile = TileManager.GetExistTile(tileKey);
Camera.main.transform.position = new Vector3(
startTile.transform.position.x,
startTile.transform.position.y,
Camera.main.transform.position.z);
var summonEffect = EffectManager.Get().ShowEnemySpawnEffect(startTile.transform.position);
var summon = Run.WaitSeconds(0.3f)
.ExecuteWhenDone(() => {
EnemyManager enemyManager = EnemyManager.Create(enemyPrefab, startTile, type, enemyId);
enemyManager.Init();
enemies.Add(enemyId, enemyManager);
});
Run.Join(new List <Run> {
summonEffect, summon
})
.ExecuteWhenDone(() => {
if (Network.isServer)
{
Slinqable.Slinq(enemies.Values)
.FirstOrNone((enemyManager) => enemyManager.GetMoveState() == EnemyManager.MoveState.MakingEnemy)
.ForEach((enemyManager) => enemyManager.OnEnemyMakingEffectEnd());
}
});
}
public LeftUIComps.Player GetPlayerUI(NetworkViewID playerId)
{
Option <LeftUIComps.Player> optionalPlayer = Slinqable.Slinq(players).FirstOrNone((player) => player.GetId() == playerId);
return(optionalPlayer.ValueOr(() => {
throw new Exception("CannotGetUI");
}));
}
public static string GetEnemyIdOnTile(int tileKey)
{
var enemies = GameManager.gameManagerInstance.GetEnemiesList();
return(Slinqable.Slinq(enemies).Where(
(enemyManager) => enemyManager.GetCurrentTileKey() == tileKey
).First().enemyId);
}
public static int GetPlayerCountAt(int tileKey)
{
var players = GameManager.GetAllPlayersEnumerator();
return(Slinqable.Slinq(players).Where(
(characterManager) => characterManager.GetCurrentTileKey() == tileKey
).Count());
}
public static bool IsPlayerEncounter(int tileKey)
{
var players = GameManager.GetAllPlayersEnumerator();
return(Slinqable.Slinq(players).Where(
(characterManager) => characterManager.GetCurrentTileKey() == tileKey
).FirstOrNone().isSome);
}
public static int GetEnemyCountAt(int tileKey)
{
var enemies = GameManager.gameManagerInstance.GetEnemiesList();
return(Slinqable.Slinq(enemies).Where(
(enemyManager) => enemyManager.GetCurrentTileKey() == tileKey
).Count());
}
public static bool IsEnemyEncounter(int tileKey)
{
var enemies = GameManager.gameManagerInstance.GetEnemiesList();
return(Slinqable.Slinq(enemies).Where(
(enemyManager) => enemyManager.GetCurrentTileKey() == tileKey
).FirstOrNone().isSome);
}
void RemoveItem(Character.Item item)
{
Slinqable.Slinq(inventoryUI.itemCardComps)
.FirstOrNone((itemCard) => itemCard.GetItem() == item)
.ForEachOr(
(itemCard) => itemCard.SetItem(Character.Item.None, null),
() => { throw new Exception("Cannot get item"); }
);
}
void SetDestination(Dictionary <TileManager.TileDirection, Tile> movableDictionaryWithoutSaveTiles)
{
Slinqable.Slinq(movableDictionaryWithoutSaveTiles.Values).
OrderBy((tile) => Random.Range(0, 100))
.FirstOrNone()
.ForEachOr(
(tile) => toMoveTile = tile,
() => Debug.LogError("Cannot find next tile")
);
}
public static NetworkViewID GetPlayerIdOnTile(int tileKey)
{
var players = GameManager.GetAllPlayersEnumerator();
var player = Slinqable.Slinq(players).Where(
(characterManager) => characterManager.GetCurrentTileKey() == tileKey
).First();
return(GameManager.GetNetworkViewID(player));
}
public void SetPortrait()
{
Option <Sprite> portraitSprite = Slinqable.Slinq(BattleUIManager.Get().leftUI.classSprite)
.FirstOrNone((classSprite) => classSprite.charClass == this.charClass)
.Select((classSprite) => classSprite.sprite);
portraitSprite.ForEachOr(
(sprite) => this.portrait.sprite = sprite,
() => Debug.LogError("Cannot find sprite for left ui.")
);
}
public void AddItemCard(Character.Item item)
{
Slinqable.Slinq(inventoryUI.itemCardComps).FirstOrNone(
(itemCard) => itemCard.GetItem() == Character.Item.None
).ForEachOr(
(itemCard) => {
var sprite = GetSpriteOfItem(item);
itemCard.SetItem(item, sprite);
},
() => Debug.Log("There is no empty imte.")
);
}
public void CreateCharacters()
{
myCharacterManager = CharacterManager.CreateInStart(characterPrefab, arrowPrefab, playerClasses[NetworkManager.networkInstance.Id]);
myCharacterManager.Init();
Slinqable.Slinq(otherPlayers).ForEach(
(otherPlayerId) => {
otherCharacterManagers.Add(otherPlayerId,
CharacterManager.CreateInStart(characterPrefab, arrowPrefab, playerClasses[otherPlayerId]));
otherCharacterManagers[otherPlayerId].Init();
}
);
}
public Sprite GetSpriteOfItem(Character.Item item)
{
var sprite = Slinqable.Slinq(itemSprites).FirstOrNone(
(itemSprite) => itemSprite.item == item
)
.Select(
(itemSprite) => itemSprite.sprite
)
.ValueOr(
() => { throw new System.Exception("cannot get item sprite"); }
);
return(sprite);
}
void RearrangeInventory()
{
var items = Slinqable.Slinq(inventoryUI.itemCardComps)
.Select((itemCard) => itemCard.GetItem())
.Where((item) => item != Character.Item.None)
.ToList();
Slinqable.Slinq(inventoryUI.itemCardComps)
.ForEach((itemCard) => itemCard.SetItem(Character.Item.None, null));
items.ForEach(
(item) => { AddItemCard(item); }
);
}
public static NetworkViewID GetNetworkViewID(CharacterManager player)
{
if (gameManagerInstance.isMyCharacterManager(player))
{
return(NetworkManager.networkInstance.Id);
}
else
{
return(Slinqable.Slinq(gameManagerInstance.otherPlayers).Where(
(playerId) => {
var otherPlayer = gameManagerInstance.otherCharacterManagers[playerId];
return otherPlayer == player;
}).First());
}
}
public void SetPlayers(List <NetworkViewID> playerIds, Dictionary <NetworkViewID, Character.CharClass> playerClasses)
{
if (playerIds.Count > leftUI.playerUIs.Count)
{
Debug.LogError("Not enough UI slot for character");
}
Queue <GameObject> playerUIs = new Queue <GameObject>(leftUI.playerUIs);
var players = Slinqable.Slinq(playerIds).Select((playerId) => {
var playerUI = playerUIs.Dequeue();
return(new LeftUIComps.Player(playerUI, playerId, playerClasses[playerId]));
});
this.players = players.ToList();
}
void InitializeDice()
{
Slinqable.Slinq(ui.attackDices)
.ForEach((attackDice) => {
attackDice.SetActive(false);
});
Queue <BDice.Species> attackDiceSpecies = new Queue <BDice.Species>(attackDices);
Slinqable.Slinq(ui.attackDices)
.Reverse()
.Take(attackDices.Count)
.ForEach((attackDice) => {
attackDice.SetActive(true);
if (attackDiceSpecies.Dequeue() == BDice.Species.Four)
{
attackDice.SendMessage("roll4ByNumber", 1);
}
else
{
attackDice.SendMessage("rollByNumber", 1);
}
});
Slinqable.Slinq(ui.defenseDices)
.ForEach((defenseDice) => {
defenseDice.SetActive(false);
});
Queue <BDice.Species> defenseDiceSpecies = new Queue <BDice.Species>(defenseDices);
Slinqable.Slinq(ui.defenseDices)
.Reverse()
.Take(defenseDices.Count)
.ForEach((defenseDice) => {
defenseDice.SetActive(true);
if (defenseDiceSpecies.Dequeue() == BDice.Species.Four)
{
defenseDice.SendMessage("roll4ByNumber", 1);
}
else
{
defenseDice.SendMessage("rollByNumber", 1);
}
});
}
Run DiceReroll()
{
//Add effect.
int minDiceValue = Slinqable.Slinq(playerCalcResult.diceResults)
.Select((diceResult) => diceResult.diceValue).Min();
int indexOfLowestDice = playerCalcResult.diceResults.FindIndex(
(diceResult) => diceResult.diceValue == minDiceValue);
//FIXME ui is reversed.
int indexOfLowestDiceUI = player.ui.attackDices.Length - 1 - indexOfLowestDice;
if (attackOrDefense == AttackOrDefense.Attack)
{
//Add re-roll effect playerDice @player.ui.attackDices[i]
int diceResult = Dice.Roll(player.attackDices[indexOfLowestDice]);
Debug.Log("Attack dicke to reroll is " + indexOfLowestDice);
player.ui.attackDices [indexOfLowestDiceUI].SendMessage("rollByNumber", diceResult);
var animationGameObject = player.ui.attackDices[indexOfLowestDiceUI];
var diceAnimation = animationGameObject.GetComponent <DiceAnimation>();
totalPlayerDice += (diceResult - minDiceValue);
playerCalcResult.totalDiceResult = totalPlayerDice;
return(Run.WaitSeconds(0.1f).Then(() => Run.WaitWhile(diceAnimation.IsRollAnimating)));
}
else
{
int diceResult = Dice.Roll(player.defenseDices[indexOfLowestDice]);
Debug.Log("Defense dicke to reroll is " + indexOfLowestDice);
player.ui.defenseDices [indexOfLowestDiceUI].SendMessage("rollByNumber", diceResult);
var animationGameObject = player.ui.attackDices[indexOfLowestDiceUI];
var diceAnimation = animationGameObject.GetComponent <DiceAnimation>();
totalPlayerDice += (diceResult - minDiceValue);
playerCalcResult.totalDiceResult = totalPlayerDice;
return(Run.WaitSeconds(0.1f).Then(() => Run.WaitWhile(diceAnimation.IsRollAnimating)));
}
}
public void GameStart()
{
gameOverObj = gameOverImg;
var enemyInfos = enemyInfoList.GetEnemyInfoList();
Slinqable.Slinq(enemyInfos).ForEach(
(enemyInfo) => {
NetworkManager.MakeEnemy(enemyInfo);
}
);
NetworkManager.SetTurnOrder(
NetworkManager.networkInstance.Id, otherPlayers);
CreateCharacters();
NetworkManager.SendGameStartMessage();
NetworkManager.SendTurnStartMessage(NetworkManager.networkInstance.Id);
}
public Run ScaleBuffUI(Character.Item item)
{
float scale = 1.5f;
float effectTime = 0.5f;
Vector3 scaleVector = new Vector3(scale, scale, 1);
Option <Run> effect = Slinqable.Slinq(ui.battleBuffUIs)
.Where((buffUI) => buffUI.item == item)
.FirstOrNone()
.Select((buffUI) => {
var buffGO = buffUI.spriteRenderer.gameObject;
iTween.ScaleTo(buffGO, iTween.Hash("scale", scaleVector, "time", effectTime));
return(Run.WaitSeconds(effectTime)
.ExecuteWhenDone(() => {
iTween.ScaleTo(buffGO, iTween.Hash("scale", Vector3.one, "time", effectTime));
})
.Then(() => Run.WaitSeconds(effectTime)));
});
return(effect.ValueOr(Run.WaitSeconds(0)));
}
public void EnableBuffUI(Character.Item item)
{
Slinqable.Slinq(ui.battleBuffUIs)
.Where((buffUI) => buffUI.item == item)
.ForEach((buffUI) => buffUI.spriteRenderer.enabled = true);
}
public Option <string> GetFirstEnemyId()
{
return(Slinqable.Slinq(enemies.Keys).FirstOrNone());
}
void AnimateDice()
{
int playerDiceNum = playerCalcResult.diceResults.Count;
int enemyDiceNum = enemyCalcResult.diceResults.Count;
GameObject animationGameObject = null;
Action <List <BDiceResult>, GameObject[]> render = (diceResults, uiDices) => {
Queue <BDiceResult> diceResultQueue = new Queue <BDiceResult>(diceResults);
Slinqable.Slinq(uiDices)
.Reverse()
.Take(diceResults.Count)
.ForEach((attackDice) => {
var diceResult = diceResultQueue.Dequeue();
if (diceResult.species == BDice.Species.Four)
{
attackDice.SendMessage("roll4ByNumber", diceResult.diceValue);
}
else
{
attackDice.SendMessage("rollByNumber", diceResult.diceValue);
}
animationGameObject = attackDice;
});
};
if (attackOrDefense == AttackOrDefense.Attack)
{
render(playerCalcResult.diceResults, player.ui.attackDices);
render(enemyCalcResult.diceResults, enemy.ui.defenseDices);
}
else
{
render(playerCalcResult.diceResults, player.ui.defenseDices);
render(enemyCalcResult.diceResults, enemy.ui.attackDices);
}
//Wait for animation end.
var diceAnimation = animationGameObject.GetComponent <DiceAnimation>();
Run.WaitSeconds(0.1f)
.Then(() => Run.WaitWhile(diceAnimation.IsRollAnimating))
.Then(() => Run.WaitSeconds(0.1f))
.ExecuteWhenDone(() => {
totalPlayerDice = playerCalcResult.totalDiceResult;
totalEnemyDice = enemyCalcResult.totalDiceResult;
player.SetTotalDiceResult(totalPlayerDice);
enemy.SetTotalDiceResult(totalEnemyDice);
Run useItem = Run.WaitSeconds(0);
//------------------DiceChange
if (useItemsInBattle.Contains(Character.Item.DiceChange) == true)
{
Debug.Log("DiceChangeSkill used.");
useItem = useItem.Then(() => ShowItemScaleEffect(Character.Item.DiceChange))
.ExecuteWhenDone(() => {
ChangeDiceWithEnemy();
useItemsInBattle.Remove(Character.Item.DiceChange);
UpdateBuffUI();
UpdateTotalDiceResult();
});
}
//------------------DiceResultChange
if (useItemsInBattle.Contains(Character.Item.DiceResultChange) == true)
{
useItem = useItem.Then(() => {
var diceRollWait = DiceReroll();
var diceRollScale = ShowItemScaleEffect(Character.Item.DiceResultChange);
return(Run.Join(new List <Run> {
diceRollWait, diceRollScale
})
.ExecuteWhenDone(() => {
useItemsInBattle.Remove(Character.Item.DiceResultChange);
UpdateBuffUI();
}));
});
}
useItem.ExecuteWhenDone(() => {
//show animation with calculation result.
totalPlayerDice = playerCalcResult.totalDiceResult;
totalEnemyDice = enemyCalcResult.totalDiceResult;
player.SetTotalDiceResult(totalPlayerDice);
enemy.SetTotalDiceResult(totalEnemyDice);
state = State.ShowDamage;
Run.Coroutine(AnimateDamage(totalPlayerDice, totalEnemyDice));
});
});
}