MinigameTeam.cs

using UnityEngine;
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using LiberiNet;
using Janus;

[Serializable]
public class MinigameTeam
{
    public int TeamIndex
    {
        get { return Array.IndexOf(Minigame.Instance.Teams, this); }
    }

    public MinigamePlayer[] PlayerSlots
    {
        get { return _playerSlots; }
    }

    public int NumPlayers
    {
        get { return _playerSlots.Count(slot => slot != null); }
    }

    public int NumHumanPlayers
    {
        get { return _playerSlots.Count(slot => slot != null && slot.IsHuman); }
    }

    public int NumBotPlayers
    {
        get { return _playerSlots.Count(slot => slot != null && slot.IsBot); }
    }

    public int NumEmptySlots
    {
        get { return _playerSlots.Count(slot => slot == null); }
    }

    public MinigamePlayer[] Players
    {
        get { return _playerSlots.Where(slot => slot != null).ToArray(); }
    }

    public MinigamePlayer[] HumanPlayers
    {
        get { return _playerSlots.Where(slot => slot != null && slot.IsHuman).ToArray(); }
    }

    public MinigamePlayer[] BotPlayers
    {
        get { return _playerSlots.Where(slot => slot != null && slot.IsBot).ToArray(); }
    }

    public MinigamePlayer[] EmptySlots
    {
        get { return _playerSlots.Where(slot => slot == null).ToArray(); }
    }

    public int[] PlayerSlotIndices
    {
        get { return Players.Select<MinigamePlayer, int>(slot => Array.IndexOf(_playerSlots, slot)).ToArray(); }
    }

    public int[] HumanPlayerSlotIndices
    {
        get { return HumanPlayers.Select<MinigamePlayer, int>(slot => Array.IndexOf(_playerSlots, slot)).ToArray(); }
    }

    public int[] BotPlayerSlotIndices
    {
        get { return BotPlayers.Select<MinigamePlayer, int>(slot => Array.IndexOf(_playerSlots, slot)).ToArray(); }
    }

    public int[] EmptySlotIndices
    {
        get
        {
            List<int> emptySlotIndices = new List<int>();

            for (int i = 0; i < _playerSlots.Length; i++)
            {
                if (_playerSlots[i] == null)
                    emptySlotIndices.Add(i);
            }

            return emptySlotIndices.ToArray();
        }
    }

    public int[] HumanPlayerPeerIndices
    {
        get { return HumanPlayers.Select<MinigamePlayer, int>(slot => slot.PeerIndex).ToArray(); }
    }

    public GameObject[] PlayerAvatars
    {
        get { return (from player in Players where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public GameObject[] HumanAvatars
    {
        get { return (from player in HumanPlayers where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public GameObject[] BotAvatars
    {
        get { return (from player in BotPlayers where player.Avatar != null select player.Avatar).ToArray(); }
    }

    public string[] HumanPlayerIDs
    {
        get { return HumanPlayers.Select<MinigamePlayer, string>(slot => slot.PlayerID).ToArray(); }
    }

    public PlayerProfile[] HumanPlayerProfiles
    {
        get { return HumanPlayers.Select<MinigamePlayer, PlayerProfile>(slot => slot.PlayerProfile).ToArray(); }
    }

    public string[] HumanPlayerNicknames
    {
        get { return HumanPlayers.Select<MinigamePlayer, string>(slot => slot.PlayerProfile.Basic.Nickname).ToArray(); }
    }

    public bool IsFull
    {
        get { return NumPlayers >= MaxPlayers; }
    }

    public bool IsFullOfHumans
    {
        get { return NumHumanPlayers >= MaxPlayers; }
    }

    public int FirstEmptySlotIndex
    {
        get
        {
            for (int i = 0; i < _playerSlots.Length; i++)
            {
                if (_playerSlots[i] == null)
                    return i;
            }

            return -1;
        }
    }

    public string ID = "players";
    public int MaxPlayers = 10;
    public GameObject AvatarPrefab;
    public Transform[] SpawnPoints;
    public Color TeamColor = Color.white;
    public Color[] SlotColors = new Color[] { Color.white };

    MinigamePlayer[] _playerSlots;

    internal void Initialize ()
    {
        _playerSlots = new MinigamePlayer[MaxPlayers];
    }

    public Color GetSlotColor (int slotIndex)
    {
        if (SlotColors.Length == 0)
            return Color.white;

        return SlotColors[slotIndex % SlotColors.Length];
    }


    public T[] GetPlayerAvatarComponents<T> () where T : Component
    {
        return PlayerAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    public T[] GetHumanAvatarComponents<T> () where T : Component
    {
        return HumanAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    public T[] GetBotAvatarComponents<T> () where T : Component
    {
        return BotAvatars.Select(a => a.GetComponent<T>()).ToArray();
    }

    internal void InsertPlayer (int slotIndex, MinigamePlayer player)
    {
        if (_playerSlots[slotIndex] == null)
        {
            _playerSlots[slotIndex] = player;
            player.Team = this;
        }
    }

    public int GetPlayerSlotIndex (MinigamePlayer player)
    {
        return Array.IndexOf(_playerSlots, player);
    }

    public MinigamePlayer GetPlayer (int slotIndex)
    {
        if (slotIndex >= MaxPlayers)
            return null;

        return _playerSlots[slotIndex];
    }

    internal void RemovePlayer (MinigamePlayer player)
    {
        if (player.Team != this)
            return;

        _playerSlots[player.SlotIndex] = null;
        player.Team = null;
    }

    internal void ClearPlayers ()
    {
        for (int i = 0; i < _playerSlots.Length; i++)
        {
            var playerSlot = _playerSlots[i];

            if (playerSlot != null)
            {
                if (playerSlot.Avatar != null)
                    Sync.Despawn(playerSlot.Avatar);

                playerSlot.Team = null;
            }

            _playerSlots[i] = null;
        }
    }

    public Transform GetSpawnPoint (int slotIndex)
    {
        if (SpawnPoints.Length == 0)
            return Minigame.Instance.transform;

        return SpawnPoints[slotIndex % SpawnPoints.Length];
    }
}