1067 lines
55 KiB
C#
1067 lines
55 KiB
C#
using System.Collections.Generic;
|
|
|
|
public class HiresManagerRebirth
|
|
{
|
|
private static HiresManagerRebirth instance = null;
|
|
private static readonly object Locker = new object();
|
|
|
|
public static bool loadedHires = false;
|
|
|
|
private const string saveFile = "RebirthManager.dat";
|
|
private static ThreadManager.ThreadInfo dataSaveThreadInfo;
|
|
|
|
public static List<hireInfo> playerHires = new List<hireInfo>();
|
|
|
|
public static List<chunkObservers> observers = new List<chunkObservers>();
|
|
|
|
private static float updateCheck = 0f;
|
|
private static float updateTick = 10f;
|
|
|
|
public static bool HasInstance => instance != null;
|
|
|
|
public class chunkObservers
|
|
{
|
|
public int entityID;
|
|
public ChunkManager.ChunkObserver observerRef;
|
|
|
|
public chunkObservers()
|
|
{
|
|
}
|
|
|
|
public chunkObservers(int entityID, ChunkManager.ChunkObserver observerRef)
|
|
{
|
|
this.entityID = entityID;
|
|
this.observerRef = observerRef;
|
|
}
|
|
}
|
|
|
|
public class hireInfo
|
|
{
|
|
public int playerID;
|
|
public int hireID;
|
|
public string name;
|
|
public string className;
|
|
public Vector3 spawnPosition;
|
|
public Vector3 spawnRotation;
|
|
public Vector3 reSpawnPosition;
|
|
public Vector3 reSpawnRotation;
|
|
public int numKills;
|
|
public int numMine;
|
|
public int order;
|
|
public bool playerSpawned;
|
|
//eventually add backpack and toolbelt content
|
|
|
|
public hireInfo()
|
|
{
|
|
}
|
|
|
|
public hireInfo(int playerID,
|
|
int hireID,
|
|
string name,
|
|
string className,
|
|
Vector3 spawnPosition,
|
|
Vector3 spawnRotation,
|
|
Vector3 reSpawnPosition,
|
|
Vector3 reSpawnRotation,
|
|
int numKills,
|
|
int numMine,
|
|
int order,
|
|
bool playerSpawned = false
|
|
)
|
|
{
|
|
this.playerID = playerID;
|
|
this.hireID = hireID;
|
|
this.name = name;
|
|
this.className = className;
|
|
this.spawnPosition = spawnPosition;
|
|
this.spawnRotation = spawnRotation;
|
|
this.reSpawnPosition = reSpawnPosition;
|
|
this.reSpawnRotation = reSpawnRotation;
|
|
this.numKills = numKills;
|
|
this.numMine = numMine;
|
|
this.order = order;
|
|
this.playerSpawned = playerSpawned;
|
|
}
|
|
}
|
|
|
|
public static HiresManagerRebirth Instance
|
|
{
|
|
get
|
|
{
|
|
return instance;
|
|
}
|
|
}
|
|
public static void Init()
|
|
{
|
|
HiresManagerRebirth.instance = new HiresManagerRebirth();
|
|
//Log.Out("Starting Hires Manager");
|
|
Load();
|
|
//Log.Out("HiresManagerRebirth-Init LOADED HIRES");
|
|
loadedHires = true;
|
|
ModEvents.GameUpdate.RegisterHandler(Update);
|
|
}
|
|
|
|
public static void Update()
|
|
{
|
|
//lock (Locker)
|
|
{
|
|
if (!RebirthUtilities.IsHordeNight() && (Time.time - updateCheck) > updateTick)
|
|
{
|
|
updateCheck = Time.time;
|
|
|
|
bool isClient = SingletonMonoBehaviour<ConnectionManager>.Instance.IsClient;
|
|
|
|
if (!isClient)
|
|
{
|
|
for (int i = 0; i < observers.Count; i++)
|
|
{
|
|
bool foundHire = false;
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
if (observers[i].entityID == hire.hireID && (hire.order == 1 || hire.order == 2))
|
|
{
|
|
foundHire = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundHire)
|
|
{
|
|
GameManager.Instance.RemoveChunkObserver(observers[i].observerRef);
|
|
observers.RemoveAt(i);
|
|
//Log.Out("HiresManagerRebirth-Update A REMOVED OBSERVER");
|
|
break;
|
|
}
|
|
}
|
|
|
|
List<EntityPlayer> spawnedPlayers = new List<EntityPlayer>();
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
EntityPlayer player = GameManager.Instance.World.GetEntity(hire.playerID) as EntityPlayer;
|
|
|
|
if (player)
|
|
{
|
|
if (player.IsSpawned() && !player.AttachedToEntity)
|
|
{
|
|
if (!spawnedPlayers.Contains(player))
|
|
{
|
|
spawnedPlayers.Add(player);
|
|
}
|
|
|
|
//Log.Out("HiresManagerRebirth-Update Player Spawned: " + hire.playerID);
|
|
if (hire.order == 1 || hire.order == 2)
|
|
{
|
|
bool foundHire = false;
|
|
|
|
foreach (chunkObservers observer in observers)
|
|
{
|
|
if (observer.entityID == hire.hireID)
|
|
{
|
|
foundHire = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundHire)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update ADDED CHUNK OBSERVER for: " + hire.hireID);
|
|
ChunkManager.ChunkObserver observerRef = GameManager.Instance.AddChunkObserver(hire.spawnPosition, false, 3, -1);
|
|
observers.Add(new chunkObservers(hire.hireID, observerRef));
|
|
}
|
|
}
|
|
else if (hire.order == 0)
|
|
{
|
|
for (int i = 0; i < observers.Count; i++)
|
|
{
|
|
if (observers[i].entityID == hire.hireID)
|
|
{
|
|
GameManager.Instance.RemoveChunkObserver(observers[i].observerRef);
|
|
observers.RemoveAt(i);
|
|
//Log.Out("HiresManagerRebirth-Update REMOVED OBSERVER");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
hire.playerSpawned = true;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update Player NOT Spawned: " + hire.playerID);
|
|
}
|
|
}
|
|
|
|
////Log.Out("HiresManagerRebirth-Update hire.playerID: " + hire.playerID);
|
|
//Log.Out("HiresManagerRebirth-Update hire.hireID: " + hire.hireID);
|
|
//Log.Out("HiresManagerRebirth-Update hire.name: " + hire.name);
|
|
//Log.Out("HiresManagerRebirth-Update hire.className: " + hire.className);
|
|
//Log.Out("HiresManagerRebirth-Update hire.spawnPosition: " + hire.spawnPosition);
|
|
//Log.Out("HiresManagerRebirth-Update hire.spawnRotation: " + hire.spawnRotation);
|
|
//Log.Out("HiresManagerRebirth-Update hire.reSpawnPosition: " + hire.reSpawnPosition);
|
|
//Log.Out("HiresManagerRebirth-Update hire.reSpawnRotation: " + hire.reSpawnRotation);
|
|
////Log.Out("HiresManagerRebirth-Update hire.numKills: " + hire.numKills);
|
|
////Log.Out("HiresManagerRebirth-Update hire.numMine: " + hire.numMine);
|
|
////Log.Out("HiresManagerRebirth-Update hire.order: " + hire.order);
|
|
//Log.Out("HiresManagerRebirth-Update hire.playerSpawned: " + hire.playerSpawned);
|
|
|
|
}
|
|
|
|
//Log.Out("HiresManagerRebirth-Update observers.Count: " + observers.Count);
|
|
|
|
/*foreach (chunkObservers observer in observers)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update observer: " + observer.entityID);
|
|
//Log.Out("HiresManagerRebirth-Update observer.observerRef.position: " + observer.observerRef.position);
|
|
}*/
|
|
|
|
foreach (EntityPlayer player in spawnedPlayers)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update CHECKING PLAYER: " + player.entityId + " / OWNED HIRES: " + playerHires.Count);
|
|
|
|
if (player.Buffs.HasBuff("god") || player.Buffs.HasBuff("FuriousRamsayDelay-10") || player.Buffs.HasBuff("FuriousRamsayDelay-5") || player.AttachedToEntity)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Chunk chunkPlayer = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos((int)player.position.x, (int)player.position.z);
|
|
|
|
for (int i = 0; i < playerHires.Count; i++)
|
|
{
|
|
hireInfo hire = playerHires[i];
|
|
|
|
//Log.Out("HiresManagerRebirth-Update CHECKING HIRE: " + hire.hireID + " / entity: " + hire.className + " / rsSpawnPosition: " + hire.reSpawnPosition);
|
|
|
|
if (hire.playerID == player.entityId)
|
|
{
|
|
EntityNPCRebirth hiredNPC = GameManager.Instance.World.GetEntity(hire.hireID) as EntityNPCRebirth;
|
|
|
|
if (hiredNPC == null)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update HIRE COULDN'T BE FOUND IN WORLD");
|
|
|
|
Vector3 respawnPosition = new Vector3(0, 0, 0);
|
|
Vector3 respawnRotation = new Vector3(0, 0, 0);
|
|
|
|
if (hire.reSpawnPosition != new Vector3(0, 0, 0))
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires RESPAWN POINT WAS SET, USING IT");
|
|
respawnPosition = hire.reSpawnPosition;
|
|
respawnRotation.y = player.rotation.y;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires NO RESPAWN POINT WAS SET, USING BEDROLL IF ONE EXISTS");
|
|
SpawnPosition spawnPoint = RebirthUtilities.GetSpawnPoint(player);
|
|
|
|
if (spawnPoint.IsUndef())
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires NO BEDROLL FOUND, USING PLAYER'S POSITION");
|
|
respawnPosition = player.position;
|
|
respawnRotation.y = player.rotation.y;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires BEDROLL FOUND, USING IT");
|
|
respawnPosition = spawnPoint.position;
|
|
respawnRotation.y = player.rotation.y;
|
|
}
|
|
|
|
}
|
|
|
|
//Log.Out("HiresManagerRebirth-CheckHires Player's position: " + player.position);
|
|
//Log.Out("HiresManagerRebirth-CheckHires respawnPosition: " + respawnPosition);
|
|
|
|
Chunk chunkHire = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos((int)respawnPosition.x, (int)respawnPosition.z);
|
|
|
|
//Log.Out("HiresManagerRebirth-Update chunkPlayer pos: " + chunkPlayer.ChunkPos);
|
|
|
|
if (chunkHire != null && (
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x + 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x - 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z - 1)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x + 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z - 1)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x - 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z + 1)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x + 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z + 1)) ||
|
|
|
|
((chunkHire.ChunkPos.x == chunkPlayer.ChunkPos.x - 1) &&
|
|
(chunkHire.ChunkPos.z == chunkPlayer.ChunkPos.z))
|
|
)
|
|
)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update chunkHire pos: " + chunkHire.ChunkPos);
|
|
|
|
Entity entity = player.world.GetEntity(hire.hireID);
|
|
|
|
if (entity == null)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update ADDED MISSING HIRE: " + hire.hireID);
|
|
|
|
EntityNPCRebirth NewEntity = EntityFactory.CreateEntity(EntityClass.FromString(hire.className), respawnPosition, respawnRotation) as EntityNPCRebirth;
|
|
NewEntity.SetSpawnerSource(EnumSpawnerSource.StaticSpawner);
|
|
NewEntity._strMyName = hire.name;
|
|
|
|
RebirthUtilities.SetLeaderAndOwner(NewEntity.entityId, player.entityId);
|
|
|
|
NewEntity.IsEntityUpdatedInUnloadedChunk = true;
|
|
NewEntity.bWillRespawn = true;
|
|
NewEntity.bIsChunkObserver = true;
|
|
NewEntity.belongsPlayerId = player.entityId;
|
|
NewEntity.guardPosition = respawnPosition;
|
|
|
|
bool addObserver = false;
|
|
|
|
GameManager.Instance.World.SpawnEntityInWorld(NewEntity);
|
|
|
|
int oldHireID = hire.hireID;
|
|
|
|
hire.hireID = NewEntity.entityId;
|
|
hire.order = 1;
|
|
SaveCurrent();
|
|
|
|
//Log.Out("HiresManagerRebirth-Update player.entityId: " + player.entityId);
|
|
//Log.Out("HiresManagerRebirth-Update NewEntity.entityId: " + NewEntity.entityId);
|
|
RebirthManager.UpdateHireInfo(oldHireID, "newid", "", "", "", NewEntity.entityId);
|
|
|
|
if (hire.order == (int)EntityUtilities.Orders.None)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO FOLLOW");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Follow);
|
|
}
|
|
else if (hire.order == (int)EntityUtilities.Orders.Follow)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO STAY");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Stay);
|
|
addObserver = true;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO STAY (GUARD)");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Stay);
|
|
addObserver = true;
|
|
}
|
|
|
|
RebirthUtilities.SetLeaderAndOwner(NewEntity.entityId, player.entityId);
|
|
|
|
bool foundObserver = false;
|
|
|
|
for (int j = 0; j < observers.Count; j++)
|
|
{
|
|
if (observers[j].entityID == hire.hireID)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires UPDATED OBSERVER, hire: " + hire.hireID);
|
|
observers[j].entityID = NewEntity.entityId;
|
|
foundObserver = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
float flMode = player.Buffs.GetCustomVar("varNPCModMode");
|
|
float flHalt = player.Buffs.GetCustomVar("varNPCModStopAttacking");
|
|
|
|
if (flMode == 0)
|
|
{
|
|
NewEntity.Buffs.AddBuff("buffNPCModFullControlMode");
|
|
}
|
|
else
|
|
{
|
|
NewEntity.Buffs.RemoveBuff("buffNPCModFullControlMode");
|
|
}
|
|
|
|
if (flHalt == 1)
|
|
{
|
|
NewEntity.Buffs.AddBuff("buffNPCModStopAttacking");
|
|
}
|
|
else
|
|
{
|
|
NewEntity.Buffs.RemoveBuff("buffNPCModStopAttacking");
|
|
}
|
|
|
|
if (addObserver && !foundObserver)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires ADDED CHUNK OBSERVER, hire: " + hire.hireID);
|
|
ChunkManager.ChunkObserver observerRef = GameManager.Instance.AddChunkObserver(NewEntity.position, false, 3, -1);
|
|
observers.Add(new chunkObservers(NewEntity.entityId, observerRef));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires HIRE EXISTS AT THIS POSITION: " + entity.position);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*foreach (hireInfo hire in playerHires)
|
|
{
|
|
Log.Out("HiresManagerRebirth-Update hire.hireID: " + hire.hireID);
|
|
Log.Out("HiresManagerRebirth-Update hire.className: " + hire.className);
|
|
Log.Out("HiresManagerRebirth-Update hire.playerSpawned: " + hire.playerSpawned);
|
|
}*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void RemoveHire(int entityID, bool removeObserver = false)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire entityID: " + entityID);
|
|
|
|
bool foundHire = false;
|
|
|
|
for (int i = 0; i < playerHires.Count; i++)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire 2, playerHires[i].hireID: " + playerHires[i].hireID);
|
|
if (playerHires[i].hireID == entityID)
|
|
{
|
|
foundHire = true;
|
|
//Log.Out("HiresManagerRebirth-RemoveHire 3");
|
|
|
|
if (SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire IS SERVER");
|
|
|
|
if (RebirthUtilities.SendToClient(playerHires[i].playerID))
|
|
{
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendPackage(NetPackageManager.GetPackage<NetPackageRemoveHireRebirth>().Setup(entityID
|
|
), false, playerHires[i].playerID, -1, -1, null, 192);
|
|
//Log.Out("HiresManagerRebirth-RemoveHire SENT TO CLIENT");
|
|
}
|
|
|
|
playerHires.RemoveAt(i);
|
|
|
|
if (removeObserver)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire 4");
|
|
for (int j = 0; j < observers.Count; j++)
|
|
{
|
|
if (observers[j].entityID == entityID)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire REMOVED OBSERVER, hire: " + entityID);
|
|
GameManager.Instance.RemoveChunkObserver(observers[j].observerRef);
|
|
observers.RemoveAt(j);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SaveCurrent();
|
|
}
|
|
else
|
|
{
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendToServer(NetPackageManager.GetPackage<NetPackageRemoveHireRebirth>().Setup(entityID
|
|
), false);
|
|
playerHires.RemoveAt(i);
|
|
//Log.Out("HiresManagerRebirth-RemoveHire SENT TO SERVER");
|
|
}
|
|
|
|
//Log.Out("HiresManagerRebirth-RemoveHire Removed Hire: " + entityID);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundHire)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire COULD NOT FIND HIRE");
|
|
if (SingletonMonoBehaviour<ConnectionManager>.Instance.IsClient)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-RemoveHire IS CLIENT");
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendToServer(NetPackageManager.GetPackage<NetPackageRemoveHireRebirth>().Setup(entityID
|
|
), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void AddHire(int playerID,
|
|
int hireID,
|
|
string name,
|
|
string className,
|
|
Vector3 spawnPosition,
|
|
Vector3 spawnRotation,
|
|
Vector3 reSpawnPosition,
|
|
Vector3 reSpawnRotation,
|
|
int numKills,
|
|
int numMine,
|
|
int order,
|
|
bool playerSpawned
|
|
)
|
|
{
|
|
bool foundHire = false;
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
if (hire.playerID == playerID && hire.hireID == hireID)
|
|
{
|
|
foundHire = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundHire)
|
|
{
|
|
hireInfo newHire = new hireInfo();
|
|
newHire.playerID = playerID;
|
|
newHire.hireID = hireID;
|
|
newHire.name = name;
|
|
newHire.className = className;
|
|
newHire.spawnPosition = spawnPosition;
|
|
newHire.spawnRotation = spawnRotation;
|
|
newHire.reSpawnPosition = reSpawnPosition;
|
|
newHire.reSpawnRotation = reSpawnRotation;
|
|
newHire.numMine = numKills;
|
|
newHire.numKills = numMine;
|
|
newHire.order = order;
|
|
newHire.playerSpawned = playerSpawned;
|
|
playerHires.Add(newHire);
|
|
|
|
EntityAlive entity = GameManager.Instance.World.GetEntity(hireID) as EntityAlive;
|
|
|
|
if (entity != null)
|
|
{
|
|
entity.Buffs.SetCustomVar("$Leader", playerID);
|
|
}
|
|
}
|
|
|
|
if (SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer)
|
|
{
|
|
SaveCurrent();
|
|
|
|
if (RebirthUtilities.SendToClient(playerID))
|
|
{
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendPackage(NetPackageManager.GetPackage<NetPackageAddHireRebirth>().Setup(playerID,
|
|
hireID,
|
|
name,
|
|
className,
|
|
spawnPosition,
|
|
spawnRotation,
|
|
reSpawnPosition,
|
|
reSpawnRotation,
|
|
numKills,
|
|
numMine,
|
|
order,
|
|
playerSpawned
|
|
), false, playerID, -1, -1, null, 192);
|
|
//Log.Out("HiresManagerRebirth-AddHire SENT TO CLIENT");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendToServer(NetPackageManager.GetPackage<NetPackageAddHireRebirth>().Setup(playerID,
|
|
hireID,
|
|
name,
|
|
className,
|
|
spawnPosition,
|
|
spawnRotation,
|
|
reSpawnPosition,
|
|
reSpawnRotation,
|
|
numKills,
|
|
numMine,
|
|
order,
|
|
playerSpawned
|
|
), false);
|
|
//Log.Out("HiresManagerRebirth-AddHire SENT TO SERVER");
|
|
}
|
|
|
|
//Log.Out("HiresManagerRebirth-AddHire Added Hire: " + hireID);
|
|
}
|
|
|
|
public static void UpdateHireInfo(int hiredID, string action, string value, string position = "", string rotation = "", int newhiredID = -1)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo START");
|
|
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo hireID: " + hiredID);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo action: " + action);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo value: " + value);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo position: " + position);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo rotation: " + rotation);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo newhiredID: " + newhiredID);
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
if (hire.hireID == hiredID || hire.hireID == newhiredID)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo FOUND HIRE");
|
|
bool changed = false;
|
|
bool addObserver = false;
|
|
bool removeObserver = false;
|
|
|
|
if (action == "newid")
|
|
{
|
|
changed = true;
|
|
}
|
|
else if (action == "order")
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo order value: " + value);
|
|
|
|
if (value == "follow")
|
|
{
|
|
hire.order = 0;
|
|
changed = true;
|
|
removeObserver = true;
|
|
}
|
|
else if (value == "stay")
|
|
{
|
|
hire.order = 1;
|
|
hire.spawnPosition = StringParsers.ParseVector3(position);
|
|
hire.spawnRotation = StringParsers.ParseVector3(rotation);
|
|
changed = true;
|
|
addObserver = true;
|
|
}
|
|
else if (value == "guard")
|
|
{
|
|
hire.order = 2;
|
|
hire.spawnPosition = StringParsers.ParseVector3(position);
|
|
hire.spawnRotation = StringParsers.ParseVector3(rotation);
|
|
changed = true;
|
|
addObserver = true;
|
|
}
|
|
}
|
|
else if (action == "reSpawnPosition")
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo reSpawnPosition: " + position);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo reSpawnRotation: " + rotation);
|
|
hire.reSpawnPosition = StringParsers.ParseVector3(position);
|
|
hire.reSpawnRotation = StringParsers.ParseVector3(rotation);
|
|
hire.spawnPosition = StringParsers.ParseVector3(position);
|
|
hire.spawnRotation = StringParsers.ParseVector3(rotation);
|
|
|
|
changed = true;
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo CHANGE HIRE INFO");
|
|
|
|
if (SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer)
|
|
{
|
|
SaveCurrent();
|
|
|
|
bool sendToClient = RebirthUtilities.SendToClient(hire.playerID);
|
|
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo sendToClient: " + sendToClient);
|
|
|
|
if (sendToClient)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo current ID: " + hiredID);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo new ID: " + newhiredID);
|
|
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendPackage(NetPackageManager.GetPackage<NetPackageChangeHireInfoRebirth>().Setup(hire.playerID,
|
|
hiredID,
|
|
hire.name,
|
|
hire.spawnPosition,
|
|
hire.spawnRotation,
|
|
hire.reSpawnPosition,
|
|
hire.reSpawnRotation,
|
|
hire.numKills,
|
|
hire.numMine,
|
|
hire.order,
|
|
hire.playerSpawned,
|
|
action,
|
|
value,
|
|
newhiredID
|
|
), false, hire.playerID, -1, -1, null, 192);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo SENT TO CLIENT");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SingletonMonoBehaviour<ConnectionManager>.Instance.SendToServer(NetPackageManager.GetPackage<NetPackageChangeHireInfoRebirth>().Setup(hire.playerID,
|
|
hiredID,
|
|
hire.name,
|
|
hire.spawnPosition,
|
|
hire.spawnRotation,
|
|
hire.reSpawnPosition,
|
|
hire.reSpawnRotation,
|
|
hire.numKills,
|
|
hire.numMine,
|
|
hire.order,
|
|
hire.playerSpawned,
|
|
action,
|
|
value,
|
|
newhiredID
|
|
), false);
|
|
//Log.Out("HiresManagerRebirth-UpdateHireInfo SENT TO SERVER");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CheckHires(int playerID, int hireID)
|
|
{
|
|
EntityPlayer player = GameManager.Instance.World.GetEntity(playerID) as EntityPlayer;
|
|
|
|
if (player == null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!player.IsSpawned())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Chunk chunkPlayer = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos((int)player.position.x, (int)player.position.z);
|
|
|
|
//Log.Out("HiresManagerRebirth-CheckHires START");
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
if (hire.playerID == playerID && hire.hireID == hireID && hire.playerSpawned)
|
|
{
|
|
if (SingletonMonoBehaviour<ConnectionManager>.Instance.IsServer)
|
|
{
|
|
bool addObserver = false;
|
|
|
|
//Log.Out("HiresManagerRebirth-CheckHires playerID: " + playerID + " / hireID: " + hireID);*/
|
|
|
|
Vector3 position = player.position;
|
|
Vector3 rotation = player.rotation;
|
|
|
|
bool setPosition = false;
|
|
|
|
if (hire.order == 1 || hire.order == 2 && hire.spawnPosition != new Vector3(0, 0, 0))
|
|
{
|
|
position = hire.spawnPosition;
|
|
rotation = hire.spawnRotation;
|
|
setPosition = true;
|
|
//Log.Out("HiresManagerRebirth-CheckHires SPAWN WHERE THEY LAST STAYED: " + position);
|
|
}
|
|
|
|
if (hire.reSpawnPosition != new Vector3(0, 0, 0))
|
|
{
|
|
position = hire.reSpawnPosition;
|
|
rotation = hire.reSpawnRotation;
|
|
hire.order = 1;
|
|
setPosition = true;
|
|
//Log.Out("HiresManagerRebirth-CheckHires SPAWNING AT REGROUP POINT: " + position);
|
|
}
|
|
|
|
if (!setPosition)
|
|
{
|
|
SpawnPosition spawnPoint = RebirthUtilities.GetSpawnPoint(player);
|
|
|
|
if (!spawnPoint.IsUndef() && spawnPoint.position != new Vector3(0, 0, 0))
|
|
{
|
|
position = spawnPoint.position;
|
|
rotation = player.rotation;
|
|
hire.order = 1;
|
|
setPosition = true;
|
|
//Log.Out("HiresManagerRebirth-CheckHires SPAWNING AT BEDROLL: " + position);
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires SPAWNING AT PLAYER LOCATION: " + position);
|
|
}
|
|
}
|
|
|
|
Chunk chunkHire = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos((int)position.x, (int)position.z);
|
|
|
|
if (chunkHire != null)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires chunkHire pos: " + chunkHire.ChunkPos);
|
|
//Log.Out("HiresManagerRebirth-CheckHires chunkPlayer pos: " + chunkPlayer.ChunkPos);
|
|
}
|
|
|
|
if (chunkHire != null)
|
|
{
|
|
Entity entity = GameManager.Instance.World.GetEntity(hire.hireID) as Entity;
|
|
|
|
if (entity == null)
|
|
{
|
|
bool skipEntity = true; // false;
|
|
|
|
if (!skipEntity)
|
|
{
|
|
////Log.Out("HiresManagerRebirth-CheckHires Couldn't find owned entity in the world");
|
|
|
|
//Log.Out("HiresManagerRebirth-CheckHires Created Missing Hire: " + hireID + " / " + hire.className + " / " + hire.name);
|
|
|
|
EntityNPCRebirth NewEntity = EntityFactory.CreateEntity(EntityClass.FromString(hire.className), position, rotation) as EntityNPCRebirth;
|
|
NewEntity.SetSpawnerSource(EnumSpawnerSource.StaticSpawner);
|
|
NewEntity._strMyName = hire.name;
|
|
|
|
RebirthUtilities.SetLeaderAndOwner(NewEntity.entityId, player.entityId);
|
|
|
|
NewEntity.IsEntityUpdatedInUnloadedChunk = true;
|
|
NewEntity.bWillRespawn = true;
|
|
NewEntity.bIsChunkObserver = true;
|
|
NewEntity.belongsPlayerId = playerID;
|
|
NewEntity.guardPosition = position;
|
|
|
|
if (hire.order == (int)EntityUtilities.Orders.None)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO FOLLOW B");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Follow);
|
|
}
|
|
else if (hire.order == (int)EntityUtilities.Orders.Follow)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO STAY B");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Stay);
|
|
addObserver = true;
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Update SET TO STAY (GUARD) B");
|
|
NewEntity.Buffs.SetCustomVar("CurrentOrder", (int)EntityUtilities.Orders.Stay);
|
|
addObserver = true;
|
|
}
|
|
|
|
GameManager.Instance.World.SpawnEntityInWorld(NewEntity);
|
|
hire.hireID = NewEntity.entityId;
|
|
|
|
RebirthUtilities.SetLeaderAndOwner(NewEntity.entityId, player.entityId);
|
|
|
|
bool foundObserver = false;
|
|
|
|
for (int i = 0; i < observers.Count; i++)
|
|
{
|
|
if (observers[i].entityID == hireID)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires UPDATED OBSERVER, hire: " + hireID);
|
|
observers[i].entityID = NewEntity.entityId;
|
|
foundObserver = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
float flMode = player.Buffs.GetCustomVar("varNPCModMode");
|
|
float flHalt = player.Buffs.GetCustomVar("varNPCModStopAttacking");
|
|
|
|
if (flMode == 0)
|
|
{
|
|
NewEntity.Buffs.AddBuff("buffNPCModFullControlMode");
|
|
}
|
|
else
|
|
{
|
|
NewEntity.Buffs.RemoveBuff("buffNPCModFullControlMode");
|
|
}
|
|
|
|
if (flHalt == 1)
|
|
{
|
|
NewEntity.Buffs.AddBuff("buffNPCModStopAttacking");
|
|
}
|
|
else
|
|
{
|
|
NewEntity.Buffs.RemoveBuff("buffNPCModStopAttacking");
|
|
}
|
|
|
|
if (addObserver && !foundObserver)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires ADDED CHUNK OBSERVER, hire: " + hireID);
|
|
ChunkManager.ChunkObserver observerRef = GameManager.Instance.AddChunkObserver(position, false, 3, -1);
|
|
observers.Add(new chunkObservers(NewEntity.entityId, observerRef));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//Log.Out("HiresManagerRebirth-CheckHires CAN'T LOAD HIRE CHUNK: " + position);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static void Write(BinaryWriter _bw)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Write playerHires.Count: " + playerHires.Count);
|
|
|
|
foreach (hireInfo hire in playerHires)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Write hire.playerID: " + hire.playerID);
|
|
//Log.Out("HiresManagerRebirth-Write hire.hireID: " + hire.hireID);
|
|
//Log.Out("HiresManagerRebirth-Write hire.name: " + hire.name);
|
|
_bw.Write(hire.playerID.ToString());
|
|
_bw.Write(hire.hireID.ToString());
|
|
_bw.Write(hire.name);
|
|
_bw.Write(hire.className);
|
|
_bw.Write(hire.spawnPosition.ToString());
|
|
_bw.Write(hire.spawnRotation.ToString());
|
|
_bw.Write(hire.reSpawnPosition.ToString());
|
|
_bw.Write(hire.reSpawnRotation.ToString());
|
|
_bw.Write(hire.numKills.ToString());
|
|
_bw.Write(hire.numMine.ToString());
|
|
_bw.Write(hire.order.ToString());
|
|
_bw.Write(hire.playerSpawned);
|
|
}
|
|
}
|
|
|
|
public static void Read(BinaryReader _br)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Read START");
|
|
|
|
while (_br.BaseStream.Position != _br.BaseStream.Length)
|
|
{
|
|
hireInfo hire = new hireInfo();
|
|
hire.playerID = int.Parse(_br.ReadString());
|
|
hire.hireID = int.Parse(_br.ReadString());
|
|
hire.name = _br.ReadString();
|
|
hire.className = _br.ReadString();
|
|
hire.spawnPosition = StringParsers.ParseVector3(_br.ReadString());
|
|
hire.spawnRotation = StringParsers.ParseVector3(_br.ReadString());
|
|
hire.reSpawnPosition = StringParsers.ParseVector3(_br.ReadString());
|
|
hire.reSpawnRotation = StringParsers.ParseVector3(_br.ReadString());
|
|
hire.numKills = int.Parse(_br.ReadString());
|
|
hire.numMine = int.Parse(_br.ReadString());
|
|
hire.order = int.Parse(_br.ReadString());
|
|
hire.playerSpawned = _br.ReadBoolean();
|
|
playerHires.Add(hire);
|
|
|
|
//Log.Out("NetPackageGetHiresRebirth-Read Added playerID: " + hire.playerID);
|
|
//Log.Out("NetPackageGetHiresRebirth-Read Added hire: " + hire.hireID);
|
|
//Log.Out("NetPackageGetHiresRebirth-Read Added name: " + hire.name);
|
|
//Log.Out("NetPackageGetHiresRebirth-Read hire.order: " + hire.order);
|
|
////Log.Out("NetPackageGetHiresRebirth-Read GameManager.IsDedicatedServer: " + GameManager.IsDedicatedServer);
|
|
}
|
|
}
|
|
|
|
private static int saveDataThreaded(ThreadManager.ThreadInfo _threadInfo)
|
|
{
|
|
//Log.Out("HiresManagerRebirth-saveDataThreaded START");
|
|
PooledExpandableMemoryStream pooledExpandableMemoryStream = (PooledExpandableMemoryStream)_threadInfo.parameter;
|
|
string text = string.Format("{0}/{1}", GameIO.GetSaveGameDir(), saveFile);
|
|
if (!Directory.Exists(GameIO.GetSaveGameDir()))
|
|
{
|
|
Directory.CreateDirectory(GameIO.GetSaveGameDir());
|
|
}
|
|
if (File.Exists(text))
|
|
{
|
|
File.Copy(text, string.Format("{0}/{1}", GameIO.GetSaveGameDir(), $"{saveFile}.bak"), true);
|
|
}
|
|
pooledExpandableMemoryStream.Position = 0L;
|
|
StreamUtils.WriteStreamToFile(pooledExpandableMemoryStream, text);
|
|
|
|
pooledExpandableMemoryStream.Dispose();
|
|
|
|
////Log.Out($"Broadcast Manager {text} Saving: {Broadcastmap.Count}");
|
|
|
|
return -1;
|
|
}
|
|
|
|
public static void Save()
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Save START");
|
|
|
|
if (dataSaveThreadInfo == null || !ThreadManager.ActiveThreads.ContainsKey("silent_HiresManagerDataSave"))
|
|
{
|
|
PooledExpandableMemoryStream pooledExpandableMemoryStream = MemoryPools.poolMemoryStream.AllocSync(true);
|
|
using (PooledBinaryWriter pooledBinaryWriter = MemoryPools.poolBinaryWriter.AllocSync(false))
|
|
{
|
|
pooledBinaryWriter.SetBaseStream(pooledExpandableMemoryStream);
|
|
Write(pooledBinaryWriter);
|
|
}
|
|
|
|
dataSaveThreadInfo = ThreadManager.StartThread("silent_HiresManagerDataSave", null, new ThreadManager.ThreadFunctionLoopDelegate(saveDataThreaded), null, System.Threading.ThreadPriority.Normal, pooledExpandableMemoryStream, null, false);
|
|
}
|
|
}
|
|
|
|
public static void Load()
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Load START");
|
|
|
|
string path = string.Format("{0}/{1}", GameIO.GetSaveGameDir(), saveFile);
|
|
if (Directory.Exists(GameIO.GetSaveGameDir()) && File.Exists(path))
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Load 1");
|
|
|
|
try
|
|
{
|
|
using (FileStream fileStream = File.OpenRead(path))
|
|
{
|
|
using (PooledBinaryReader pooledBinaryReader = MemoryPools.poolBinaryReader.AllocSync(false))
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Load 2");
|
|
pooledBinaryReader.SetBaseStream(fileStream);
|
|
Read(pooledBinaryReader);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
path = string.Format("{0}/{1}", GameIO.GetSaveGameDir(), $"{saveFile}.bak");
|
|
if (File.Exists(path))
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Load 3");
|
|
|
|
using (FileStream fileStream2 = File.OpenRead(path))
|
|
{
|
|
using (PooledBinaryReader pooledBinaryReader2 = MemoryPools.poolBinaryReader.AllocSync(false))
|
|
{
|
|
//Log.Out("HiresManagerRebirth-Load 4");
|
|
|
|
pooledBinaryReader2.SetBaseStream(fileStream2);
|
|
Read(pooledBinaryReader2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void WaitOnSave()
|
|
{
|
|
if (dataSaveThreadInfo != null)
|
|
{
|
|
dataSaveThreadInfo.WaitForEnd();
|
|
dataSaveThreadInfo = null;
|
|
}
|
|
}
|
|
|
|
public static void Cleanup()
|
|
{
|
|
if (instance != null)
|
|
{
|
|
SaveAndClear();
|
|
}
|
|
}
|
|
|
|
public static void SaveCurrent()
|
|
{
|
|
//Log.Out("HiresManagerRebirth-SaveCurrent SAVED CURRENT");
|
|
WaitOnSave();
|
|
Save();
|
|
WaitOnSave();
|
|
}
|
|
|
|
private static void SaveAndClear()
|
|
{
|
|
WaitOnSave();
|
|
Save();
|
|
WaitOnSave();
|
|
playerHires.Clear();
|
|
observers.Clear();
|
|
instance = null;
|
|
//Log.Out("Hires Manager stopped");
|
|
}
|
|
} |