private void attack_sweep(string type = "")
{
this.callTitanHAHA();
this.state = "attack_sweep";
this.attackAnimation = "sweep" + type;
this.attackCheckTimeA = 0.4f;
this.attackCheckTimeB = 0.57f;
this.checkHitCapsuleStart = baseT.Find("Amarture/Core/Controller_Body/hip/spine/chest/shoulder_R/upper_arm_R/forearm_R");
this.checkHitCapsuleEnd = baseT.Find("Amarture/Core/Controller_Body/hip/spine/chest/shoulder_R/upper_arm_R/forearm_R/hand_R/hand_R_001");
this.checkHitCapsuleR = 20f;
this.crossFade("attack_" + this.attackAnimation, 0.1f);
this.attackChkOnce = false;
this.sweepSmokeObject.GetComponent <ParticleSystem>().enableEmission = true;
this.sweepSmokeObject.GetComponent <ParticleSystem>().Play();
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer)
{
if (FengGameManagerMKII.LAN)
{
if (Network.peerType == NetworkPeerType.Server)
{
}
}
else if (PhotonNetwork.IsMasterClient)
{
BasePV.RPC("startSweepSmoke", PhotonTargets.Others, new object[0]);
}
}
}
public void AskForPickupItemSpawnTimes()
{
if (this.IsWaitingForPickupInit)
{
if (PhotonNetwork.playerList.Length < 2)
{
Debug.Log("Cant ask anyone else for PickupItem spawn times.");
this.IsWaitingForPickupInit = false;
return;
}
PhotonPlayer next = PhotonNetwork.masterClient.GetNext();
if (next == null || next.Equals(PhotonNetwork.player))
{
next = PhotonNetwork.player.GetNext();
}
if (next != null && !next.Equals(PhotonNetwork.player))
{
BasePV.RPC("RequestForPickupTimes", next, new object[0]);
}
else
{
Debug.Log("No player left to ask");
this.IsWaitingForPickupInit = false;
}
}
}
private void RequestAnarchyVersion(PhotonMessageInfo info)
{
if (info.Sender.CanRequestVersion)
{
BasePV.RPC(nameof(ReceiveAnarchyVersion), info.Sender, new object[] { AnarchyManager.AnarchyVersion.ToString(), true, AnarchyManager.CustomName });
}
}
private void humanGetsPoint()
{
if (this.humanPt >= this.humanPtMax)
{
this.humanPt = this.humanPtMax;
this.titanPt = 0f;
this.syncPts();
this.state = CheckPointState.Human;
BasePV.RPC("changeState", PhotonTargets.All, new object[]
{
1
});
if (FengGameManagerMKII.Level.MapName != "The City I")
{
this.supply = Optimization.Caching.Pool.NetworkEnable("aot_supply", base.transform.position - Vectors.up * (base.transform.position.y - this.getHeight(base.transform.position)), base.transform.rotation, 0);
}
(FengGameManagerMKII.FGM.logic as GameLogic.PVPCaptureLogic).PVPHumanScore += 2;
FengGameManagerMKII.FGM.CheckPVPpts();
if (this.checkIfHumanWins())
{
FengGameManagerMKII.FGM.GameWin();
}
}
else
{
this.humanPt += Time.deltaTime;
}
}
public void Drop()
{
if (this.PickupIsMine)
{
BasePV.RPC("PunRespawn", PhotonTargets.AllViaServer, new object[0]);
}
}
public void OnPhotonPlayerConnected(AOTEventArgs args)
{
if (PhotonNetwork.IsMasterClient)
{
BasePV.RPC("changeTitanPt", args.Player, new object[] { this.titanPt });
BasePV.RPC("changeHumanPt", args.Player, new object[] { this.humanPt });
}
}
private void Awake()
{
if (!BasePV.IsMine)
{
return;
}
BasePV.RPC("OnAwakeRPC", PhotonTargets.All, new object[0]);
}
public void setHair()
{
if (SkinSettings.SkinsCheck(SkinSettings.TitanSkins) && SkinSettings.TitanSet.Value != Anarchy.Configuration.StringSetting.NotDefine)
{
Anarchy.Configuration.Presets.TitanSkinPreset set = new Anarchy.Configuration.Presets.TitanSkinPreset(SkinSettings.TitanSet.Value);
set.Load();
int num = UnityEngine.Random.Range(0, 9);
if (num == 3)
{
num = 9;
}
skin = set.RandomizePairs ? Random.Range(0, 5) : skin;
if (set.HairTypes[skin] >= 0)
{
num = (int)set.HairTypes[skin];
}
string hair = set.Hairs[skin];
int num3 = Random.Range(1, 8);
if (hasEye)
{
num3 = 0;
}
if (hair.EndsWith(".png") || hair.EndsWith(".jpg") || hair.EndsWith(".jpeg"))
{
ApplyHairSkin(num, num3, hair);
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer && PhotonNetwork.IsMasterClient && SkinSettings.TitanSkins.Value != 2)
{
BasePV.RPC("setHairRPC2", PhotonTargets.OthersBuffered, new object[] { num, num3, hair });
}
}
else
{
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer)
{
Color hair_color = HeroCostume.costume[UnityEngine.Random.Range(0, HeroCostume.costume.Length - 5)].hair_color;
object[] parameters = new object[]
{
num,
num3,
hair_color.r,
hair_color.g,
hair_color.b
};
BasePV.RPC("setHairPRC", PhotonTargets.AllBuffered, parameters);
}
else
{
Color hair_color = HeroCostume.costume[UnityEngine.Random.Range(0, HeroCostume.costume.Length - 5)].hair_color;
this.setHairPRC(num, num3, hair_color.r, hair_color.g, hair_color.b);
}
}
}
else if (IN_GAME_MAIN_CAMERA.GameType == GameType.Single || BasePV.IsMine)
{
setHairVanilla();
}
}
public void Awake()
{
bool flag = BasePV != null;
if (flag)
{
BasePV.observed = this;
this.barrel = base.transform.Find("Barrel");
this.correctPlayerPos = base.transform.position;
this.correctPlayerRot = base.transform.rotation;
this.correctBarrelRot = this.barrel.rotation;
bool isMine = BasePV.IsMine;
if (isMine)
{
this.firingPoint = this.barrel.Find("FiringPoint");
this.ballPoint = this.barrel.Find("BallPoint");
this.myCannonLine = this.ballPoint.GetComponent <LineRenderer>();
bool flag2 = base.gameObject.name.Contains("CannonGround");
if (flag2)
{
this.isCannonGround = true;
}
}
bool isMasterClient = PhotonNetwork.IsMasterClient;
if (isMasterClient)
{
PhotonPlayer owner = BasePV.owner;
bool flag3 = RCManager.allowedToCannon.ContainsKey(owner.ID);
if (flag3)
{
this.settings = RCManager.allowedToCannon[owner.ID].settings;
BasePV.RPC("SetSize", PhotonTargets.All, new object[]
{
this.settings
});
int viewID = RCManager.allowedToCannon[owner.ID].viewID;
RCManager.allowedToCannon.Remove(owner.ID);
CannonPropRegion component = PhotonView.Find(viewID).gameObject.GetComponent <CannonPropRegion>();
bool flag4 = component != null;
if (flag4)
{
component.disabled = true;
component.destroyed = true;
PhotonNetwork.Destroy(component.gameObject);
}
}
else
{
bool flag5 = !owner.IsLocal;// && !FengGameManagerMKII.instance.restartingMC;
if (flag5)
{
//TO DO
//FengGameManagerMKII.instance.kickPlayerRC(owner, false, "spawning cannon without request.");
}
}
}
}
}
public void Pickup()
{
if (this.SentPickup)
{
return;
}
this.SentPickup = true;
BasePV.RPC("PunPickup", PhotonTargets.AllViaServer, new object[0]);
}
public void titanGetHit(int viewID, int hitSpeed)
{
var photonView = PhotonView.Find(viewID);
if (photonView == null)
{
return;
}
var magnitude = (photonView.gameObject.transform.position - Neck.position).magnitude;
if (magnitude < lagMax && !hasDie && Time.time - healthTime > 0.2f)
{
healthTime = Time.time;
if (GameModes.DamageMode.Enabled && hitSpeed < GameModes.DamageMode.GetInt(0))
{
FengGameManagerMKII.FGM.BasePV.RPC("netShowDamage", photonView.owner, hitSpeed);
if (maxHealth > 0)
{
BasePV.RPC("labelRPC", PhotonTargets.AllBuffered, currentHealth, maxHealth);
}
return;
}
currentHealth -= hitSpeed;
if (maxHealth > 0)
{
BasePV.RPC("labelRPC", PhotonTargets.AllBuffered, currentHealth, maxHealth);
}
if (currentHealth <= 0)
{
OnTitanDie(photonView);
BasePV.RPC("netDie", PhotonTargets.OthersBuffered);
if (grabbedTarget != null)
{
grabbedTarget.BasePV.RPC("netUngrabbed", PhotonTargets.All);
}
netDie();
if (nonAI)
{
FengGameManagerMKII.FGM.TitanGetKill(photonView.owner, hitSpeed,
(string)PhotonNetwork.player.Properties[PhotonPlayerProperty.name]);
}
else
{
FengGameManagerMKII.FGM.TitanGetKill(photonView.owner, hitSpeed, ShowName);
}
}
else
{
FengGameManagerMKII.FGM.BasePV.RPC("netShowDamage", photonView.owner, hitSpeed);
}
}
}
public void titanGetHit(int viewID, int speed)
{
if (FengGameManagerMKII.LAN)
{
}
Transform transform = baseT.Find("Amarture/Core/Controller_Body/hip/spine/chest/neck");
PhotonView photonView = PhotonView.Find(viewID);
if (photonView == null)
{
return;
}
float magnitude = (photonView.gameObject.transform.position - transform.transform.position).magnitude;
if (magnitude < lagMax && !this.hasDie && this.healthTime <= 0f)
{
healthTime = 0.2f;
if (GameModes.DamageMode.Enabled && speed < GameModes.DamageMode.GetInt(0))
{
FengGameManagerMKII.FGM.BasePV.RPC("netShowDamage", photonView.owner, new object[] { speed });
this.neckSteam();
return;
}
this.NapeArmor -= speed;
if (this.maxHealth > 0)
{
BasePV.RPC("labelRPC", PhotonTargets.AllBuffered, new object[] { NapeArmor, Mathf.RoundToInt(this.maxHealth) });
}
this.neckSteam();
if (this.NapeArmor <= 0)
{
this.NapeArmor = 0;
if (!this.hasDie)
{
if (FengGameManagerMKII.LAN)
{
this.netDie();
}
else
{
BasePV.RPC("netDie", PhotonTargets.OthersBuffered, new object[0]);
this.netDie();
FengGameManagerMKII.FGM.TitanGetKill(photonView.owner, speed, base.name);
}
}
}
else
{
FengGameManagerMKII.FGM.SendKillInfo(false, photonView.owner.UIName, true, "Colossal Titan's neck", speed);
AnarchyManager.Feed.Kill(photonView.owner.UIName, "Colossal Titan's Neck", speed);
FengGameManagerMKII.FGM.BasePV.RPC("netShowDamage", photonView.owner, new object[]
{
speed
});
}
}
}
public void TitanGetKill(PhotonPlayer player, int damage, string titanName)
{
damage = Mathf.Max(10, damage);
BasePV.RPC("netShowDamage", player, damage);
BasePV.RPC("oneTitanDown", PhotonTargets.MasterClient, titanName, false);
SendKillInfo(false, player.UIName, true, titanName, damage);
PlayerKillInfoUpdate(player, damage);
AnarchyManager.Feed.Kill(player.UIName.ToHTMLFormat(), titanName, damage);
}
public void Drop(Vector3 newPosition)
{
if (this.PickupIsMine)
{
BasePV.RPC("PunRespawn", PhotonTargets.AllViaServer, new object[]
{
newPosition
});
}
}
private void SendPickedUpItems(PhotonPlayer targtePlayer)
{
if (targtePlayer == null)
{
Debug.LogWarning("Cant send PickupItem spawn times to unknown targetPlayer.");
return;
}
double time = PhotonNetwork.time;
double num = time + 0.20000000298023224;
PickupItem[] array = new PickupItem[PickupItem.DisabledPickupItems.Count];
PickupItem.DisabledPickupItems.CopyTo(array);
List <float> list = new List <float>(array.Length * 2);
foreach (PickupItem pickupItem in array)
{
if (pickupItem.SecondsBeforeRespawn <= 0f)
{
list.Add((float)pickupItem.ViewID);
list.Add(0f);
}
else
{
double num2 = pickupItem.TimeOfRespawn - PhotonNetwork.time;
if (pickupItem.TimeOfRespawn > num)
{
Debug.Log(string.Concat(new object[]
{
pickupItem.ViewID,
" respawn: ",
pickupItem.TimeOfRespawn,
" timeUntilRespawn: ",
num2,
" (now: ",
PhotonNetwork.time,
")"
}));
list.Add((float)pickupItem.ViewID);
list.Add((float)num2);
}
}
}
Debug.Log(string.Concat(new object[]
{
"Sent count: ",
list.Count,
" now: ",
time
}));
BasePV.RPC("PickupItemInit", targtePlayer, new object[]
{
PhotonNetwork.time,
list.ToArray()
});
}
private void OnClick()
{
if (!this.DestroyByRpc)
{
PhotonNetwork.Destroy(base.gameObject);
}
else
{
BasePV.RPC("DestroyRpc", PhotonTargets.AllBuffered, new object[0]);
}
}
private void syncPts()
{
BasePV.RPC("changeTitanPt", PhotonTargets.Others, new object[]
{
this.titanPt
});
BasePV.RPC("changeHumanPt", PhotonTargets.Others, new object[]
{
this.humanPt
});
}
private void syncPts()
{
if (titanPt != _lastTitanPt)
{
BasePV.RPC("changeTitanPt", PhotonTargets.Others, new object[] { this.titanPt });
_lastTitanPt = titanPt;
}
if (humanPt != _lastHumanPt)
{
BasePV.RPC("changeHumanPt", PhotonTargets.Others, new object[] { this.humanPt });
_lastHumanPt = humanPt;
}
}
private void SetTeam(int team)
{
var nameColor = string.Empty;
switch (team)
{
case 0:
PhotonNetwork.player.RCteam = 0;
PhotonNetwork.player.UIName = User.Name.Value;
return;
case 1:
nameColor = Colors.cyan.ColorToString();
break;
case 2:
nameColor = Colors.magenta.ColorToString();
break;
case 3:
var cyans = 0;
var magentas = 0;
foreach (var player in PhotonNetwork.playerList)
{
switch (player.RCteam)
{
case 1:
cyans++;
break;
case 2:
magentas++;
break;
}
}
SetTeam(cyans > magentas ? 1 : 2);
return;
}
PhotonNetwork.player.UIName = nameColor != string.Empty ? $"[{nameColor}]{PhotonNetwork.player.UIName.RemoveHex()}" : User.Name.Value;
PhotonNetwork.player.RCteam = team;
if (team >= 0 && team < 3)
{
foreach (var hero in heroes.Where(hero => hero.IsLocal))
{
BasePV.RPC("labelRPC", PhotonTargets.All, hero.BasePV.viewID);
}
}
}
public void Launch(Vector3 v, Vector3 v2, string launcher_ref, bool isLeft, HERO hero, bool leviMode = false)
{
if (this.phase == 2)
{
return;
}
this.master = hero;
this.velocity = v;
float f = Mathf.Acos(Vector3.Dot(v.normalized, v2.normalized)) * 57.29578f;
if (Mathf.Abs(f) > 90f)
{
this.velocity2 = Vectors.zero;
}
else
{
this.velocity2 = Vector3.Project(v2, v);
}
switch (launcher_ref)
{
case "hookRefL1":
this.myRef = hero.hookRefL1;
break;
case "hookRefL2":
this.myRef = hero.hookRefL2;
break;
case "hookRefR1":
this.myRef = hero.hookRefR1;
break;
case "hookRefR2":
this.myRef = hero.hookRefR2;
break;
}
myRefT = myRef.transform;
this.nodes = new List <Vector3>();
this.nodes.Add(myRefT.position);
this.phase = 0;
this.leviMode = leviMode;
this.left = isLeft;
if (IN_GAME_MAIN_CAMERA.GameType != GameType.Single && BasePV.IsMine)
{
BasePV.RPC("myMasterIs", PhotonTargets.Others, new object[] { hero.BasePV.viewID, launcher_ref });
BasePV.RPC("setVelocityAndLeft", PhotonTargets.Others, new object[] { v, this.velocity2, this.left });
}
baseT.position = myRefT.position;
baseT.rotation = Quaternion.LookRotation(v.normalized);
}
private void playAnimation(string aniName)
{
base.animation.Play(aniName);
if (!FengGameManagerMKII.LAN)
{
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer && PhotonNetwork.IsMasterClient)
{
BasePV.RPC("netPlayAnimation", PhotonTargets.Others, new object[]
{
aniName
});
}
}
}
public void launch(Vector3 v1)
{
this.launched = true;
this.oldP = baseT.position;
this.v = v1;
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer && PhotonNetwork.IsMasterClient)
{
BasePV.RPC("launchRPC", PhotonTargets.Others, new object[]
{
this.v,
this.oldP
});
}
}
public void PlayAnimation(string aniName)
{
baseA.Play(aniName);
if (!PhotonNetwork.connected)
{
return;
}
if (BasePV.IsMine)
{
BasePV.RPC("netPlayAnimation", PhotonTargets.Others, new object[]
{
aniName
});
}
}
private void CrossFade(string aniName, float time)
{
baseA.CrossFade(aniName, time);
if (!PhotonNetwork.connected)
{
return;
}
if (BasePV.IsMine)
{
BasePV.RPC("netCrossFade", PhotonTargets.Others, new object[]
{
aniName,
time
});
}
}
public void MultiplayerRacingFinish()
{
Debug.LogError(nameof(MultiplayerRacingFinish));
var num = logic.RoundTime - ((RacingLogic)logic).StartTime;
if (PhotonNetwork.IsMasterClient)
{
getRacingResult(User.RaceName, num);
}
else
{
BasePV.RPC("getRacingResult", PhotonTargets.MasterClient, User.RaceName, num);
}
GameWin();
}
public void Disable()
{
if (isOnTrap)
{
if (master != null)
{
master.GasMultiplier = 1f;
isOnTrap = false;
}
}
this.phase = 2;
this.killTime = 0f;
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer)
{
BasePV.RPC("setPhase", PhotonTargets.Others, new object[] { 2 });
}
}
private void PlayAnimationAt(string aniName, float normalizedTime)
{
baseA.Play(aniName);
baseA[aniName].normalizedTime = normalizedTime;
if (!PhotonNetwork.connected)
{
return;
}
if (BasePV.IsMine)
{
BasePV.RPC("netPlayAnimationAt", PhotonTargets.Others, new object[]
{
aniName,
normalizedTime
});
}
}
void IGameManager.SendChatMessage(string sender, string content, int[] targets)
{
if (targets == null)
{
foreach (int id in targets)
{
var player = PhotonPlayer.Find(id);
if (player != null)
{
BasePV.RPC("Chat", player, new object[] { content, sender });
}
}
}
else
{
BasePV.RPC("Chat", PhotonTargets.All, new object[] { content, sender });
}
}
private void setMyTeam(int val)
{
myTeam = val;
if (IsLocal)
{
wLeft.myTeam = val;
wRight.myTeam = val;
}
if (IN_GAME_MAIN_CAMERA.GameType == GameType.MultiPlayer && PhotonNetwork.IsMasterClient)
{
if (GameModes.FriendlyMode.Enabled)
{
if (val != 1)
{
BasePV.RPC("setMyTeam", PhotonTargets.AllBuffered, 1);
}
}
else
{
if (GameModes.BladePvp.Enabled)
{
var team = 0;
switch (GameModes.BladePvp.Selection)
{
case 1:
team = BasePV.owner.RCteam;
break;
case 2:
team = BasePV.owner.ID;
break;
}
if (val == team)
{
return;
}
BasePV.RPC("setMyTeam", PhotonTargets.AllBuffered, team);
}
}
}
}
private void titanGetsPoint()
{
if (this.titanPt >= this.titanPtMax)
{
this.titanPt = this.titanPtMax;
this.humanPt = 0f;
this.syncPts();
if (this.state == CheckPointState.Human && this.supply != null)
{
PhotonNetwork.Destroy(this.supply);
}
this.state = CheckPointState.Titan;
BasePV.RPC("changeState", PhotonTargets.All, new object[]
{
2
});
(FengGameManagerMKII.FGM.logic as GameLogic.PVPCaptureLogic).PVPTitanScore += 2;
FengGameManagerMKII.FGM.CheckPVPpts();
if (this.checkIfTitanWins())
{
FengGameManagerMKII.FGM.GameLose();
}
if (this.hasAnnie)
{
if (!this.annie)
{
this.annie = true;
Optimization.Caching.Pool.NetworkEnable("FEMALE_TITAN", base.transform.position - Vectors.up * (base.transform.position.y - this.getHeight(base.transform.position)), base.transform.rotation, 0);
}
else
{
this.newTitan();
}
}
else
{
this.newTitan();
}
}
else
{
this.titanPt += Time.deltaTime;
}
}
