public void SetRoomInfo(int roomId, int myNewId, ReadyPlayerSampleInfo[] allPlayers, string summonerIdObserverd = null)
{
PvpProtocolTools.UpdateHeroSkins(allPlayers);
this._roomInfo.SetPlayers(roomId, myNewId, allPlayers, summonerIdObserverd);
this._roomInfo.IsOtherCancelConfirm = false;
this._isObserver = (this.MyLobbyUserId == -2147483648);
}
public static Units CreateEyeItemByUnitInfo(UnitInfo info)
{
if (!StringUtils.CheckValid(info.burnValue))
{
ClientLogger.Error(string.Concat(new object[]
{
"burnValue is invalid, use default position #",
info.typeId,
" utype:",
info.unitType
}));
return(null);
}
string[] stringValue = StringUtils.GetStringValue(info.burnValue, '|');
if (stringValue.Length != 6)
{
ClientLogger.Error("eye item burnValue is stuctured wrong");
return(null);
}
int num = -1;
if (!int.TryParse(stringValue[2], out num))
{
ClientLogger.Error("parse eye item pos failed");
return(null);
}
if (num < 0)
{
ClientLogger.Error("eye item pos invalid");
return(null);
}
Transform spawnPos = MapManager.Instance.GetSpawnPos(TeamType.Neutral, num);
TeamType teamType = PvpProtocolTools.GroupToTeam((int)info.group);
EntityVo npcinfo = new EntityVo(EntityType.Monster, info.typeId, num, 9, string.Empty, "Default", 0)
{
uid = info.unitId
};
SpawnUtility spawnUtility = GameManager.Instance.Spawner.GetSpawnUtility();
Units units = spawnUtility.SpawnEyeItemInstance(npcinfo, "Monster", teamType, "[]", spawnPos, info.position, stringValue[4], UnitControlType.None);
if (units == null)
{
ClientLogger.Error("P2C_CreateUnits create monster failed, " + StringUtils.DumpObject(info));
return(null);
}
units.SetOrigin(true, info.creepId.ToString(), info.monsterTeamId);
units.TryAddBirthEffect();
units.SetIsMonsterCreep(false);
PvpProtocolTools.SyncUnitLifeStateAndSkill(units, info, 0L);
if (units.isMonster && units.skillManager != null)
{
units.skillManager.EnableSkills(true);
}
return(units);
}
private static void SyncUnitLifeStateAndSkill(Units unit, UnitInfo unitInfo, long reliveLeftTime)
{
if (!unit)
{
return;
}
PvpProtocolTools.SyncHeroSkills(unit, unitInfo);
PvpProtocolTools.SyncUnitLifeState(unit, unitInfo, reliveLeftTime);
PvpProtocolTools.SyncHeroItems(unit, unitInfo);
PvpProtocolTools.SyncMainHeroData(unit, unitInfo);
}
public static void SyncSingleUnit(UnitRuntimeInfo unitInfo)
{
byte lifeState = unitInfo.baseUnitInfo.lifeState;
if (lifeState == 2 || lifeState == 3)
{
int unitId = unitInfo.baseUnitInfo.unitId;
PvpManager.On_KillHero(unitId, 0f, (float)TimeSpan.FromTicks(unitInfo.reliveLeftTime).TotalSeconds);
}
PvpProtocolTools.TryRecoverUnit(unitInfo);
}
public static void UpdateHeroSkins(IEnumerable <ReadyPlayerSampleInfo> allPlayers)
{
HeroSkins.Clear();
foreach (ReadyPlayerSampleInfo current in allPlayers)
{
if (!string.IsNullOrEmpty(current.heroSkinId))
{
int skinIdx = 0;
if (int.TryParse(current.heroSkinId, out skinIdx))
{
HeroSkins.SetHeroSkin(PvpProtocolTools.GroupToTeam((int)current.group), current.heroInfo.heroId, skinIdx);
}
}
}
}
public static void SyncFightInfo(InBattleRuntimeInfo fightInfo)
{
if (fightInfo == null || fightInfo.teamInfos == null)
{
return;
}
if (fightInfo.frameTime > 0)
{
FrameSyncManager.Instance.OneFrameTime = (double)((float)fightInfo.frameTime / 1000f);
}
PvpProtocolTools.ResetHeroStatistic(fightInfo);
GameManager.Instance.SurrenderMgr.SyncInfos(fightInfo.surrenderInfos);
Singleton <PvpManager> .Instance.RoomInfo.CtrlUniqueIds.Clear();
if (fightInfo.unitInfos == null)
{
return;
}
PvpProtocolTools.SyncSceneState(fightInfo.sceneValues);
Singleton <PvpManager> .Instance.GameStartTime = new DateTime?(DateTime.Now - TimeSpan.FromTicks(fightInfo.gameTime));
Dictionary <int, Units> allMapUnits = MapManager.Instance.GetAllMapUnits();
List <Units> list = new List <Units>();
foreach (Units unit in allMapUnits.Values)
{
if ((!unit.isHero && !unit.isHome && !unit.isBuilding) || unit.MirrorState)
{
if (unit.isLive)
{
UnitRuntimeInfo unitRuntimeInfo = fightInfo.unitInfos.FirstOrDefault((UnitRuntimeInfo x) => x.baseUnitInfo.unitId == unit.unique_id);
if (unitRuntimeInfo == null)
{
list.Add(unit);
}
}
}
}
foreach (Units current in list)
{
MapManager.Instance.DespawnUnit(current);
}
for (int i = 0; i < fightInfo.unitInfos.Length; i++)
{
PvpProtocolTools.SyncSingleUnit(fightInfo.unitInfos[i]);
}
Singleton <MiniMapView> .Instance.UpdateAfterReConect();
}
private void SyncFightInfo(InBattleRuntimeInfo fightInfo)
{
if (fightInfo == null)
{
PvpStateBase.LogState("no fight info");
this.TryStartOberving();
return;
}
if (fightInfo.roomState == 3)
{
Singleton <PvpManager> .Instance.AbandonGame(PvpErrorCode.StateError);
}
else
{
PvpProtocolTools.SyncFightInfo(fightInfo);
this.TryStartOberving();
}
}
private static void SetUnitState(Units unit, UnitRuntimeInfo info)
{
if (!unit)
{
return;
}
PvpProtocolTools.SyncUnitPosition(unit, info);
PvpProtocolTools.SyncUnitProperties(unit, info);
PvpProtocolTools.SyncUnitBuff(unit, info);
PvpProtocolTools.SyncUnitLifeStateAndSkill(unit, info.baseUnitInfo, info.reliveLeftTime);
Units player = PlayerControlMgr.Instance.GetPlayer();
if (player != null && player.teamType < 4)
{
unit.m_nServerVisibleState = (int)info.nVisebleState[player.teamType];
}
PvpProtocolTools.TrySyncMonsterCreepGroupType(unit, info);
PvpProtocolTools.TrySyncMonsterCreepRotation(unit);
}
private static void TryRecoverUnit(UnitRuntimeInfo info)
{
UnitInfo baseUnitInfo = info.baseUnitInfo;
Units units = MapManager.Instance.GetUnit(baseUnitInfo.unitId);
try
{
UnitType unitType = baseUnitInfo.unitType;
if (unitType != UnitType.Hero)
{
if (unitType != UnitType.Monster)
{
if (unitType != UnitType.Tower && unitType != UnitType.Home)
{
if (unitType == UnitType.MapItem)
{
if (!units)
{
PvpProtocolTools.CreateMapItem(info, UnitControlType.None);
}
goto IL_179;
}
if (unitType != UnitType.Soldier)
{
if (unitType == UnitType.FenShenHero)
{
if (!units)
{
units = PvpProtocolTools.CreateHeroByUnitInfo(info.baseUnitInfo);
}
PvpProtocolTools.SetUnitState(units, info);
goto IL_179;
}
if (unitType != UnitType.EyeUnit && unitType != UnitType.SummonMonster && unitType != UnitType.Pet && unitType != UnitType.LabisiUnit)
{
goto IL_179;
}
}
}
else
{
units = MapManager.Instance.GetUnit(baseUnitInfo.unitId);
if (!units)
{
ClientLogger.Error("TryCreateUnit: tower not found - " + StringUtils.DumpObject(baseUnitInfo));
return;
}
PvpProtocolTools.SetUnitState(units, info);
goto IL_179;
}
}
if (!units)
{
units = PvpProtocolTools.CreateMonsterByUnitInfo(info.baseUnitInfo);
}
PvpProtocolTools.SetUnitState(units, info);
}
else
{
if (!units)
{
units = MapManager.Instance.TryFetchRecycledUnit(baseUnitInfo.unitId);
if (!units)
{
ClientLogger.Error("TryCreateUnit: hero not found - " + StringUtils.DumpObject(baseUnitInfo));
return;
}
}
PvpProtocolTools.SetUnitState(units, info);
}
IL_179:
if (units)
{
units.UpdateVisible();
units.RefreshSyncState();
}
}
catch (Exception e)
{
ClientLogger.LogException(e);
}
}
private static void SyncUnitLifeState(Units unit, UnitInfo unitInfo, long reliveLeftTime)
{
try
{
PvpLifeState lifeState = (PvpLifeState)unitInfo.lifeState;
if (lifeState == PvpLifeState.Dead || lifeState == PvpLifeState.WaitRelive)
{
PvpProtocolTools.ToDie(unit, null, reliveLeftTime);
}
else
{
if (!unit.isLive)
{
if (unit.isHero)
{
SpawnUtility spawnUtility = GameManager.Instance.Spawner.GetSpawnUtility();
spawnUtility.RespawnPvpHero(unit);
}
else
{
ClientLogger.Error(string.Concat(new object[]
{
"SetUnitState: cannot relive non-hero unit #",
unit.unique_id,
" ",
unit.name,
" to state ",
lifeState
}));
}
}
if (unit.IsMonsterCreep())
{
Monster monster = unit as Monster;
if (lifeState == PvpLifeState.Unactive)
{
monster.Sleep();
}
else if (lifeState == PvpLifeState.Live)
{
if (monster.Sleeping.IsInState)
{
monster.Wakeup(false);
}
else
{
monster.Appear();
}
}
else
{
ClientLogger.Warn(string.Concat(new object[]
{
"don't know how to treat ",
unit.name,
" with life state ",
lifeState
}));
}
}
}
}
catch (Exception e)
{
ClientLogger.LogException(e);
}
}
public static TeamType GetTeam(this ReadyPlayerSampleInfo info)
{
return(PvpProtocolTools.GroupToTeam((int)info.group));
}
public static Units CreateMonsterByUnitInfo(UnitInfo info)
{
Units result;
try
{
if (info == null)
{
ClientLogger.Error("CreateMonsterByUnitInfo: info is null");
result = null;
}
else if (MapManager.Instance == null)
{
ClientLogger.Error("MapManager.Instance is null");
result = null;
}
else if (GlobalSettings.TestCreep)
{
Singleton <CreepSpawner> .Instance.CreateCreeps(new List <string>
{
"101"
}, info.unitId);
result = null;
}
else if (GlobalSettings.NoMonster)
{
ClientLogger.Warn("P2C_CreateUnits create monster ignored");
result = null;
}
else if (info.unitType == UnitType.EyeItem)
{
result = PvpProtocolTools.CreateEyeItemByUnitInfo(info);
}
else
{
TeamType teamType = PvpProtocolTools.GroupToTeam((int)info.group);
int num = -1;
Transform transform = null;
if (StringUtils.CheckValid(info.burnValue))
{
string[] stringValue = StringUtils.GetStringValue(info.burnValue, '|');
UnitType unitType = info.unitType;
if (unitType != UnitType.Monster)
{
if (unitType != UnitType.Soldier)
{
ClientLogger.Error("cannot be here");
}
else
{
num = int.Parse(stringValue[2]);
}
}
else
{
num = int.Parse(stringValue[1]);
transform = MapManager.Instance.GetSpawnPos(TeamType.Neutral, num);
}
if (num < 0)
{
ClientLogger.Error("burnValue is invalid, use position #" + info.typeId + " " + info.burnValue);
}
}
else if (info.unitType == UnitType.EyeUnit)
{
transform = MapManager.Instance.GetSpawnPos(TeamType.Neutral, 1);
if (transform != null)
{
transform.position = new Vector3(info.position.x, info.position.y, info.position.z);
}
}
else if (info.unitType == UnitType.SummonMonster || info.unitType == UnitType.BoxUnit)
{
transform = MapManager.Instance.GetSpawnPos((TeamType)info.group, 1);
if (transform != null)
{
transform.position = new Vector3(info.position.x, info.position.y, info.position.z);
}
}
else if (info.unitType == UnitType.Pet)
{
transform = MapManager.Instance.GetSpawnPos((TeamType)info.group, 1);
if (transform != null)
{
transform.position = new Vector3(info.position.x, info.position.y, info.position.z);
}
}
else if (info.unitType == UnitType.LabisiUnit)
{
transform = MapManager.Instance.GetSpawnPos((TeamType)info.group, 1);
if (transform != null)
{
transform.position = new Vector3(info.position.x, info.position.y, info.position.z);
}
}
else
{
ClientLogger.Error(string.Concat(new object[]
{
"burnValue is invalid, use default position #",
info.typeId,
" utype:",
info.unitType
}));
}
Units unit = MapManager.Instance.GetUnit(info.mainHeroId);
int skin = 0;
if (unit != null && info.unitType == UnitType.SummonMonster)
{
skin = HeroSkins.GetRealHeroSkin((TeamType)unit.teamType, unit.model_id);
}
EntityVo npcinfo = new EntityVo(EntityType.Monster, info.typeId, num, 0, string.Empty, "Default", 0)
{
uid = info.unitId,
skin = skin
};
if (null == GameManager.Instance)
{
Debug.LogError("null == GameManager.Instance");
result = null;
}
else if (GameManager.Instance.Spawner == null)
{
Debug.LogError("null == GameManager.Instance.Spawner");
result = null;
}
else
{
SpawnUtility spawnUtility = GameManager.Instance.Spawner.GetSpawnUtility();
Units units = spawnUtility.SpawnInstance(npcinfo, "Monster", teamType, num, "[]", transform, UnitControlType.None, info.unitType);
if (units == null)
{
ClientLogger.Error(string.Concat(new object[]
{
"P2C_CreateUnits create monster failed, creepId=",
info.creepId,
" typeid= ",
info.typeId,
" burnValue=",
info.burnValue ?? "null"
}));
result = null;
}
else
{
if (units.UnitType == UnitType.EyeUnit)
{
}
if (unit != null)
{
units.ParentUnit = unit;
}
if (units.UnitType == UnitType.EyeUnit || units.UnitType == UnitType.SummonMonster)
{
units.m_fLiveTime = info.liveTime;
units.m_fLeftTime = info.liveTime;
}
units.SetOrigin(true, info.creepId.ToString(), info.monsterTeamId);
units.TryAddBirthEffect();
units.SetIsMonsterCreep(info.unitType == UnitType.Monster || info.unitType == UnitType.CreepBoss);
PvpProtocolTools.SyncUnitLifeStateAndSkill(units, info, 0L);
if (units.isMonster && units.skillManager != null)
{
units.skillManager.EnableSkills(true);
}
if (units != null && transform != null)
{
units.SetPosition(transform.position, true);
}
result = units;
}
}
}
}
catch (Exception e)
{
ClientLogger.LogException(e);
result = null;
}
return(result);
}
