// Token: 0x06003F10 RID: 16144 RVA: 0x0013DE5C File Offset: 0x0013C25C
public void UpdateTeams()
{
Array values = Enum.GetValues(typeof(PunTeams.Team));
IEnumerator enumerator = values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
PunTeams.PlayersPerTeam[(PunTeams.Team)obj].Clear();
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
for (int i = 0; i < PhotonNetwork.playerList.Length; i++)
{
PhotonPlayer photonPlayer = PhotonNetwork.playerList[i];
PunTeams.Team team = photonPlayer.GetTeam();
PunTeams.PlayersPerTeam[team].Add(photonPlayer);
}
}
void Shoot(float speed, PunTeams.Team team, Vector3 spawnPos, float damage, int photonId, int shooter)
{
GameObject bullet = Instantiate(Minion.bulletPrefab, spawnPos, transform.rotation);
Bullet b = bullet.GetComponent <Bullet>();
b.Setup(damage, team, transform.position, photonId, shooter);
}
/// <summary>
/// Update button color and text
/// </summary>
public void UpdateButton()
{
assignedPlayer = null;
for (int i = 0; i < PhotonNetwork.playerList.Length; i++)
{
PhotonPlayer player = PhotonNetwork.playerList[i];
PunTeams.Team playerTeam = player.GetTeam();
PunTeams.Role playerRole = player.GetRole();
if ((playerTeam == team) && (playerRole == role))
{
assignedPlayer = player;
break;
}
}
if (assignedPlayer != null)
{
image.color = Color.red;
text.text = assignedPlayer.NickName;
}
else
{
image.color = Color.green;
text.text = "<empty>";
}
}
public void InitHPAndTeam(float hp, float maxHP, PunTeams.Team team, string n)
{
Team = team;
Health = hp;
maxHealth = maxHP;
Name = n;
if ((photonView.isMine) & (!isBot))
{
Game.PlayerHP = Health;
}
plyMat = Instantiate(GetComponent <Renderer>().material) as Material;
if (team == PunTeams.Team.red)
{
plyMat.color = Color.red;
}
else if (team == PunTeams.Team.blue)
{
plyMat.color = Color.blue;
}
foreach (Transform child in transform)
{
if (child.GetComponent <Renderer>())
{
child.GetComponent <Renderer>().material = plyMat;
}
}
GetComponent <Renderer>().material = plyMat;
}
public void VictoryOrDefeatScreen(PunTeams.Team losingTeam)
{
PunTeams.Team playerTeam = PhotonNetwork.player.GetTeam();
if (losingTeam == PunTeams.Team.blue)
{
if (playerTeam == PunTeams.Team.red)
{
GameObject.Find("VictoryCamera").GetComponent <Camera>().enabled = true;
}
else if (playerTeam == PunTeams.Team.blue)
{
GameObject.Find("DefeatCamera").GetComponent <Camera>().enabled = true;
}
}
else if (losingTeam == PunTeams.Team.red)
{
if (playerTeam == PunTeams.Team.blue)
{
GameObject.Find("VictoryCamera").GetComponent <Camera>().enabled = true;
}
else if (playerTeam == PunTeams.Team.red)
{
GameObject.Find("DefeatCamera").GetComponent <Camera>().enabled = true;
}
}
}
public virtual void AddBots()
{
if (!HasOptionBotCount)
{
return;
}
int addAmount = BotCount;
Bots.Clear();
// Adjust bot count
int maxPlayers = PhotonNetwork.room.MaxPlayers;
if (networkManager.isConnectOffline)
{
maxPlayers = networkManager.maxConnections;
}
if (PhotonNetwork.room.PlayerCount + addAmount > maxPlayers)
{
addAmount = maxPlayers - PhotonNetwork.room.PlayerCount;
}
for (var i = 0; i < addAmount; ++i)
{
var character = NewBot();
if (IsTeamGameplay)
{
character.playerTeam = tempTeam = (tempTeam == PunTeams.Team.red ? PunTeams.Team.blue : PunTeams.Team.red);
}
networkManager.RegisterCharacter(character);
Bots.Add(character);
}
}
public void PerformTurn(string teamName, int x, int y)
{
if (State == GameState.YouLost | State == GameState.YouWon | State == GameState.Tie)
{
return;
}
IntVector2 coordinates = new IntVector2(x, y);
PunTeams.Team team = Helpers.ParseEnum <PunTeams.Team>(teamName);
if (team == PunTeams.Team.none | State == GameState.WaitingForRestart)
{
return;
}
if (team == PunTeams.Team.X && State == GameState.WaitingForTurnByX ||
team == PunTeams.Team.O && State == GameState.WaitingForTurnByO)
{
if (Grid.get.PerformTurn(coordinates, team))
{
State = State == GameState.WaitingForTurnByX ? GameState.WaitingForTurnByO : (State == GameState.WaitingForTurnByO ? GameState.WaitingForTurnByX : State);
}
}
}
void OnVictory(PunTeams.Team winningTeam)
{
if (!victory)
{
victory = true;
GameObject losingNexus;
if (winningTeam == PunTeams.Team.blue)
{
losingNexus = GameObject.Find("Red Nexus");
}
else
{
losingNexus = GameObject.Find("Blue Nexus");
}
// Prevent errors in trying to move the camera to something that doesn't exist
if (losingNexus != null)
{
Vector3 pos = new Vector3(losingNexus.transform.position.x, 15f, losingNexus.transform.position.z - 15f);
Camera.main.GetComponent <PlayerCamera>().SetEndOfGameTarget(pos, 1f);
}
// End the game
StartCoroutine(VictoryEnum(winningTeam));
if (onGameEnd != null)
{
onGameEnd();
}
}
}
private void CreateBot(string _vehicle, PunTeams.Team _botTeam)
{
GameObject[] teamStartPoint = null;
switch (_botTeam)
{
case PunTeams.Team.red:
teamStartPoint = GameObject.FindGameObjectsWithTag("TeamAStartPoint");
break;
case PunTeams.Team.blue:
teamStartPoint = GameObject.FindGameObjectsWithTag("TeamBStartPoint");
break;
}
Vector3 airplaneOffsetHeight;
Transform StartPoint = respawnPointModule.RandomStartPoint(teamStartPoint, false, out airplaneOffsetHeight);
TankInitSystem vehicle = new GameObject("Vehicle", typeof(TankInitSystem)).GetComponent <TankInitSystem>();
vehicle.VehicleName = _vehicle;
vehicle._InstanceNetType = InstanceNetType.GameNetworkBotOffline;
vehicle.ownerTeam = _botTeam;
vehicle.BulletCountList = new int[] { 1000, 1000, 1000 };
vehicle.InitTankInitSystem();
vehicle.transform.position = StartPoint.position;
vehicle.transform.eulerAngles = StartPoint.eulerAngles;
}
private void CreatePlayerUI(PhotonPlayer player)
{
string key = player.UserId;
DestroyPlayerUI(key);
PunTeams.Team team = player.GetTeam();
Transform container = waitingPlayerListContainer;
Dictionary <string, UIPhotonWaitingPlayer> uiDict = waitingPlayers;
switch (team)
{
case PunTeams.Team.red:
container = waitingPlayerTeamAListContainer;
uiDict = waitingTeamAPlayers;
break;
case PunTeams.Team.blue:
container = waitingPlayerTeamBListContainer;
uiDict = waitingTeamBPlayers;
break;
}
UIPhotonWaitingPlayer newEntry = Instantiate(waitingPlayerPrefab, container);
newEntry.SetData(this, player);
newEntry.gameObject.SetActive(true);
uiDict.Add(key, newEntry);
players[player.UserId] = player;
}
void Update()
{
if (photonPlayer.CustomProperties.ContainsValue(charID))
{
//nothin
}
else
{
photonPlayer.CustomProperties.TryGetValue("PlayerID", out newID);
charID = Convert.ToInt32(newID);
character.sprite = playerImages[charID];
}
if (photonPlayer.GetTeam() != teamSet)
{
teamSet = photonPlayer.GetTeam();
if (teamSet == PunTeams.Team.blue)
{
button.color = new Color32(92, 171, 229, 254);
}
else
{
button.color = new Color32(254, 73, 92, 254);
}
}
}
/**
* Create a message indicating which team has picked up the flag.
*/
public void AddFlagPickupMessage(PunTeams.Team pickupTeam)
{
string teamStr = "";
MColor color = MColor.neutralTeam;
switch (pickupTeam)
{
case PunTeams.Team.red:
teamStr = "Red";
color = MColor.redTeam;
break;
case PunTeams.Team.blue:
teamStr = "Blue";
color = MColor.blueTeam;
break;
case PunTeams.Team.none:
teamStr = "Neutral";
color = MColor.neutralTeam;
break;
default:
Debug.Assert(false, "Panic: Invalid team value");
break;
}
string message = string.Format(">>> {0} team has the flag", teamStr);
GetComponent <PhotonView>().RPC("AddTextMessage_RPC",
PhotonTargets.AllBuffered, message, color);
}
public void RPC_PlayerDead(PunTeams.Team team)
{
if (team == PunTeams.Team.blue)
{
if (PhotonNetwork.isMasterClient)
{
bluePlayers--;
}
if (bluePlayers <= 1)
{
redWin.SetActive(true);
if (PhotonNetwork.isMasterClient)
{
GetComponent <PhotonView>().RPC("RPC_SyncInt", PhotonTargets.All, true);
}
StartCoroutine(startNewRound());
}
}
else
{
if (PhotonNetwork.isMasterClient)
{
redPlayers--;
}
if (redPlayers <= 1)
{
blueWin.SetActive(true);
if (PhotonNetwork.isMasterClient)
{
GetComponent <PhotonView>().RPC("RPC_SyncInt", PhotonTargets.All, false);
}
StartCoroutine(startNewRound());
}
}
}
public void RPC_StartSpike(Vector3 location, PunTeams.Team team, int play)
{
teamOn = team;
player = play;
isSpiked = true;
StartCoroutine(move(location));
}
public override void TakeDamage(PunTeams.Team enemyTeam, int power)
{
int newBlood;
if (bloodTeam != enemyTeam)
{
newBlood = curBlood - power;
if (newBlood <= 0)
{
newBlood *= -1;
bloodTeam = (enemyTeam);
}
}
else
{
newBlood = curBlood + power;
if (newBlood >= originBlood)
{
newBlood = originBlood;
attackBase.OnTeamChanged(bloodTeam);
}
}
if (newBlood != curBlood)
{
OnHealthChanged(newBlood);
}
}
/*public override void OnSend (NanoBuffers.NanoWriter writer)
* {
* base.OnSend (writer);
* writer.put (targetPosition);
* }
*
* public override void OnReceived (NanoBuffers.NanoReader reader)
* {
* base.OnReceived (reader);
* reader.get (out targetPosition);
* Generate ();
* }*/
void Generate()
{
PunTeams.Team myTeam = gameObject.PropertyComponent().myTeam;
Vector3 targetPosition = GetEnermyQuanShui(myTeam);
Vector3 pos = transform.position;
pos.y = 3;
GameObject ins = null;
int rd = Random.Range(0, 2);
if (rd < 1)
{
ins = magician;
}
else
{
ins = soldier;
}
total++;
GameObject obj = PhotonNetwork.InstantiateSceneObject(ins.name, pos, Quaternion.identity, 0, null);
Property p = obj.PropertyComponent();
p.myTeam = myTeam;
(p as SoldierProperty).originDestination = targetPosition;
}
public override void ChangeMaterial(PunTeams.Team newTeam)
{
base.ChangeMaterial(newTeam);
Color newColor;
if (newTeam == PunTeams.Team.none)
{
newColor = PunTeams.TeamColor [(int)newTeam];
}
else
{
if (newTeam == PhotonNetwork.player.GetTeam())
{
newColor = Color.blue;
}
else
{
newColor = Color.red;
}
}
string[] str = { "Banners", "Crystal" };
foreach (var s in str)
{
transform.Find(s).GetComponent <MeshRenderer> ().material.color = newColor;
}
}
string GetButtonLabel(PunTeams.Team team)
{
GameObject[] playerObjects = GameObject.FindGameObjectsWithTag("Player");
int playerCount = 0;
for (int i = 0; i < playerObjects.Length; ++i)
{
if (playerObjects[i].GetPhotonView().owner.GetTeam() == team)
{
playerCount++;
}
}
string label = team.ToString() + " team\n";
label += playerCount.ToString();
if (playerCount == 1)
{
label += " player";
}
else
{
label += " players";
}
return(label);
}
private void UpdatePlayerUI(PhotonPlayer player)
{
PunTeams.Team team = player.GetTeam();
if (waitingPlayers.ContainsKey(player.UserId))
{
if (team != PunTeams.Team.none)
{
// If player team changed, recreate waiting player UI
CreatePlayerUI(player);
return;
}
waitingPlayers[player.UserId].SetData(this, player);
}
if (waitingTeamAPlayers.ContainsKey(player.UserId))
{
if (team != PunTeams.Team.red)
{
// If player team changed, recreate waiting player UI
CreatePlayerUI(player);
return;
}
waitingTeamAPlayers[player.UserId].SetData(this, player);
}
if (waitingTeamBPlayers.ContainsKey(player.UserId))
{
if (team != PunTeams.Team.blue)
{
// If player team changed, recreate waiting player UI
CreatePlayerUI(player);
return;
}
waitingTeamBPlayers[player.UserId].SetData(this, player);
}
}
public bool PerformTurn(IntVector2 coordinates, PunTeams.Team team)
{
bool result = tiles[coordinates.x, coordinates.y].Occupy(team == PunTeams.Team.X ? TileState.X : TileState.O);
if (result)
{
turns += 1;
}
if (team == PhotonNetwork.player.GetTeam())
{
if (Victory())
{
if (OnGameOver != null)
{
OnGameOver(PhotonNetwork.player.GetTeam());
}
result = false;
}
else if (turns == 9)
{
if (OnGameOver != null)
{
OnGameOver(PunTeams.Team.none);
}
result = false;
}
}
return(result);
}
protected virtual void OnShowSkill(SkillType skillID, Vector3 pos)
{
if (skillID == SkillType.BianShen)
{
Skill skill = GetSkill((int)skillID);
GameObject skill_effect = GameObject.Instantiate(skill.effect, transform);
SetVisual(false);
int lastSpeed = (gameObject.PropertyComponent() as HeroProperty).speed;
AttackBase atkb = GetComponent <AttackBase> ();
PunTeams.Team lastTeam = atkb.team;
if (lastTeam == PunTeams.Team.red)
{
atkb.OnTeamChanged(PunTeams.Team.blue);
}
else
{
atkb.OnTeamChanged(PunTeams.Team.red);
}
SetSpeed(lastSpeed + 4);
DayNightController.instance.onDayNightChanged.AddListener(delegate(bool arg0) {
if (!arg0)
{
Destroy(skill_effect);
SetVisual(true);
SetSpeed(lastSpeed);
atkb.OnTeamChanged(lastTeam);
}
});
}
}
void OnGameOver(PunTeams.Team victory)
{
DayNightController.instance.enabled = false;
foreach (var item in GameObject.FindObjectsOfType <Property>())
{
item.enabled = false;
}
bool spy = (localHero.PropertyComponent() as HeroProperty).isSpy;
bool vic = false;
PunTeams.Team myTeam = PhotonNetwork.player.GetTeam();
if (spy)
{
vic = myTeam != victory;
}
else
{
vic = myTeam == victory;
}
if (vic)
{
gameImage.sprite = Resources.Load <Sprite> ("victory");
}
else
{
gameImage.sprite = Resources.Load <Sprite> ("defeat");
}
gameImage.transform.parent.gameObject.SetActive(true);
DOTween.To(() => gameImage.transform.localScale, (x) => gameImage.transform.localScale = x, new Vector3(1.2f, 1.2f, 1.2f), 1.5f);
}
void Shoot(float speed, PunTeams.Team team, float damage, Vector3 position, int photonId, int shooter)
{
transform.LookAt(new Vector3(position.x, transform.position.y, position.z));
GameObject bullet = Instantiate(bulletPrefab, (transform.position + transform.forward), transform.rotation);
Bullet b = bullet.GetComponent <Bullet>();
b.Setup(damage, team, transform.position, photonId, shooter);
}
protected void DrawLeaderboards()
{
if (GamemodeManager.CurrentGamemode.IsRoundFinished() == true)
{
m_LeaderboardsFadeIn = 1;
}
if (m_LeaderboardsFadeIn == 0)
{
return;
}
// width of all labels, plus 20 padding
float width = 665;
float height = 500;
GUILayout.BeginArea(new Rect((Screen.width - width) * 0.5f + (1 - m_LeaderboardsFadeIn) * -Screen.width, (Screen.height - height) * 0.5f, width, height), LeaderboardsBackgroundStyle);
{
GUILayout.BeginHorizontal();
{
GUILayout.Label("Name", HeaderStyle, GUILayout.Width(200));
GUILayout.Label("Kills", HeaderStyleCentered, GUILayout.Width(90));
GUILayout.Label("Deaths", HeaderStyleCentered, GUILayout.Width(135));
GUILayout.Label("K/D", HeaderStyleCentered, GUILayout.Width(80));
GUILayout.Label("Points", HeaderStyleCentered, GUILayout.Width(140));
}
GUILayout.EndHorizontal();
//Draw the list of all players and their kill counts
List <PlayerController> sortedPlayers = GetSortedPlayers();
for (int i = 0; i < sortedPlayers.Count; ++i)
{
string playerName = sortedPlayers[i].name;
if (PhotonNetwork.connected == true)
{
playerName = sortedPlayers[i].GetComponent <PhotonView>().owner.NickName;
}
GUILayout.BeginHorizontal();
{
PunTeams.Team team = sortedPlayers [i].GetComponent <PhotonView> ().owner.GetTeam();
GUI.color = GetTeamColor(team);
string kdrString = GetKDRatio(sortedPlayers [i]);
GUILayout.Label(playerName, LabelStyle, GUILayout.Width(200));
GUILayout.Label(sortedPlayers[i].killCount.ToString(), LabelStyleCentered, GUILayout.Width(90));
GUILayout.Label(sortedPlayers[i].deathCount.ToString(), LabelStyleCentered, GUILayout.Width(135));
GUILayout.Label(kdrString, LabelStyleCentered, GUILayout.Width(80));
GUILayout.Label(sortedPlayers[i].flagCaptureCount.ToString(), LabelStyleCentered, GUILayout.Width(140));
}
GUILayout.EndHorizontal();
}
}
GUILayout.EndArea();
GUI.color = Color.white;
}
/// <summary>
/// Set up the bullet on the network to travel a limited distance in a straight direction.
/// </summary>
/// <param name="_damage">The damage dealt by the bullet</param>
/// <param name="_team">The team the bullet is assigned to</param>
/// <param name="_startingPos">The 3D position in the world the bullet spawns from</param>
/// <param name="_range">The range of travel for the bullet before it is destroyed</param>
/// <param name="_shooterId">The viewID of the attacker</param>
public void Setup(float _damage, PunTeams.Team _team, Vector3 _startingPos, float _range, int _shooterId)
{
ValidateSetup();
shooterId = _shooterId;
team = _team;
damage = _damage;
startingPos = _startingPos;
range = _range;
}
void SpawnMinion(int packIndex, PunTeams.Team team)
{
if (PhotonNetwork.isMasterClient)
{
GameObject minion = PhotonNetwork.Instantiate(minionPrefab.name, Vector3.zero, Quaternion.identity, 0);
minion.GetComponent <Entity>().Init(477);
minion.GetComponent <Minion>().Init(packIndex, team);
}
}
public DamageInfo(float dmg, PunTeams.Team team, int owner)
{
Damage = dmg;
Team = team;
Owner = owner;
//OwnerObj = ownObj;
}
public void ResetFlag(PunTeams.Team team)
{
if (team == PunTeams.Team.red)
{
GameObject.Find("Torch_Red").transform.position = Util.defaultRedFlag;
}
else
{
GameObject.Find("Torch_Blue").transform.position = Util.defaultBlueFlag;
}
}
public void RPC_TakeHeal(int playerSending, PunTeams.Team playerTeam)
{
if (playerTeam == PunTeams.Team.red)
{
redImages[playerSending].takeDamage();
}
else
{
blueImages[playerSending].takeDamage();
}
}
/// <summary>
/// Set up the bullet on the network to guarantee a hit on a target.
/// </summary>
/// <param name="_damage">The damage dealt by the bullet</param>
/// <param name="_team">The team the bullet is assigned to</param>
/// <param name="_startingPos">The 3D position in the world the bullet spawns from</param>
/// <param name="photonId">The viewID of the target</param>
/// <param name="_shooterId">The viewID of the attacker</param>
public void Setup(float _damage, PunTeams.Team _team, Vector3 _startingPos, int photonId, int _shooterId)
{
ValidateSetup();
shooterId = _shooterId;
team = _team;
damage = _damage;
startingPos = _startingPos;
target = PhotonView.Find(photonId).gameObject;
capsuleCollider.enabled = false;
hadTarget = true;
}
//######SYNC#####
public void OnPhotonSerializeView( PhotonStream stream, PhotonMessageInfo info )
{
if ( stream.isWriting )
{
//Send
stream.SendNext( IsReady );
stream.SendNext( PlayerName );
stream.SendNext( PlayerSlot );
stream.SendNext( PlayerTeam );
}
else
{
//Receive
this.IsReady = ( bool )stream.ReceiveNext( );
this.PlayerName = ( string )stream.ReceiveNext( );
this.PlayerSlot = ( int )stream.ReceiveNext( );
this.PlayerTeam = ( PunTeams.Team )stream.ReceiveNext( );
}
}
