public int Reconstruct(AgentController agentController, byte[] source, int startIndex)
{
curIndex = startIndex;
Header = BitConverter.ToUInt64 (source, curIndex);
curIndex += 8;
if (selectedAgentLocalIDs == null)
selectedAgentLocalIDs = new FastList<int> (64);
else
selectedAgentLocalIDs.FastClear ();
for (i = 0; i < 64; i++) {
castedBigIndex = (ulong)1 << i;
if ((Header & castedBigIndex) == castedBigIndex) {
CullGroup = source [curIndex++];
for (j = 0; j < 8; j++) {
castedSmallIndex = (byte)(1 << j);
if ((CullGroup & (castedSmallIndex)) == castedSmallIndex)
{
selectedAgentLocalIDs.Add (i * 8 + j);
}
}
}
}
return curIndex - startIndex;
}
public static void JoinTeam(AgentController controller)
{
Teams [nextDistribute++].AddController (controller);
if (nextDistribute >= Teams.Count)
{
nextDistribute = 0;
}
}
public static void AddAgentController(AgentController agentController)
{
agentControllers.Add (agentController);
if (agentController.ControllerID >= HasAgentController.Length)
{
Array.Resize (ref HasAgentController, HasAgentController.Length * 2);
}
HasAgentController[agentController.ControllerID] = true;
}
public void Initialize()
{
Diplomacy.FastClear ();
for (int i = 0; i < TeamManager.Teams.Count; i++) {
Team team = TeamManager.Teams[i];
if (team != this)
Diplomacy.AddAt (AllegianceType.Neutral, team.ID);
}
TeamManager.UpdateDiplomacy (this);
this.SetAllegiance (this, AllegianceType.Friendly);
MainController = new AgentController();
MainController.JoinTeam (this);
}
public void Initialize()
{
Diplomacy.FastClear();
for (int i = 0; i < TeamManager.Teams.Count; i++)
{
Team team = TeamManager.Teams[i];
if (team != this)
{
this.SetAllegiance(team, AllegianceType.Neutral);
}
}
TeamManager.UpdateDiplomacy(this);
TeamManager.Teams.Add(this);
this.SetAllegiance(this, AllegianceType.Friendly);
MainController = AgentController.Create();
MainController.JoinTeam(this);
}
internal static void Execute(Command com)
{
if (!GameStarted)
{
Debug.LogError("BOOM");
return;
}
if (com.ControllerID != byte.MaxValue)
{
AgentController cont = AgentController.InstanceManagers [com.ControllerID];
cont.Execute(com);
}
else
{
BehaviourHelperManager.Execute(com);
}
DefaultMessageRaiser.Execute(com);
}
internal static void Simulate()
{
MainGameManager.MainNetworkHelper.Simulate();
DefaultMessageRaiser.EarlySimulate();
if (InfluenceCount == 0)
{
InfluenceSimulate();
InfluenceCount = InfluenceResolution - 1;
if (FrameManager.CanAdvanceFrame == false)
{
Stalled = true;
return;
}
Stalled = false;
if (InfluenceFrameCount == 0)
{
GameStart();
}
FrameManager.Simulate();
InfluenceFrameCount++;
}
else
{
InfluenceCount--;
}
if (Stalled || IsPaused)
{
return;
}
BehaviourHelperManager.Simulate();
AgentController.Simulate();
PhysicsManager.Simulate();
CoroutineManager.Simulate();
InfluenceManager.Simulate();
ProjectileManager.Simulate();
TriggerManager.Simulate();
LateSimulate();
FrameCount++;
}
public void Initialize(
AgentController controller,
ushort localID,
ushort globalID,
Vector2d position = default(Vector2d))
{
LocalID = localID;
GlobalID = globalID;
Controller = controller;
IsActive = true;
CheckCasting = true;
Selectable = true;
CachedGameObject.SetActive(true);
if (Body.IsNotNull())
{
Body.Initialize(position, Vector2d.up);
}
if (Influencer.IsNotNull())
{
Influencer.Initialize();
}
if (Animator.IsNotNull())
{
Animator.Initialize();
}
abilityManager.Initialize();
if (StatsBarer != null)
{
StatsBarer.Initialize();
}
if (Ringer.IsNotNull())
{
Ringer.Initialize();
IsSelected = false;
IsHighlighted = false;
}
}
protected override void OnLateApply()
{
foreach (EnvironmentBodyInfo info in EnvironmentBodies)
{
info.Body.Initialize(info.Position, info.Rotation);
}
foreach (EnvironmentObject obj in EnvironmentObjects)
{
obj.LateInitialize();
}
foreach (var agentInfo in EnvironmentAgents)
{
AgentController.DefaultController.AddAgent(agentInfo.Agent);
agentInfo.Agent.Setup(AgentController.GetAgentInterfacer(agentInfo.AgentCode));
agentInfo.Agent.Initialize(agentInfo.Position.ToVector2d(), agentInfo.Rotation);
agentInfo.Agent.Body.HeightPos = agentInfo.Position.z;
}
}
public static void Initialize(GameManager gameManager)
{
MainGameManager = gameManager;
SimulationTimer.Reset();
SimulationTimer.Start();
LSDatabaseManager.Initialize();
LSUtility.Initialize(1);
Interfacing.Initialize();
InfluenceCount = 0;
Time.timeScale = 1f;
Stalled = true;
FrameCount = 0;
InfluenceFrameCount = 0;
GridManager.Generate();
GridManager.Initialize();
TeamManager.Initialize();
CoroutineManager.Initialize();
FrameManager.Initialize();
CommandManager.Initialize();
BehaviourHelper.GlobalInitialize();
AgentController.Initialize();
TeamManager.LateInitialize();
PhysicsManager.Initialize();
PlayerManager.Initialize();
SelectionManager.Initialize();
InfluenceManager.Initialize();
ProjectileManager.Initialize();
LoadSceneObjects();
Started = true;
ClientManager.Initialize();
}
public void Initialize(
AgentController controller,
ushort localID,
ushort globalID,
Vector2d position = default(Vector2d),
Vector2d rotation = default(Vector2d))
{
LocalID = localID;
GlobalID = globalID;
Controller = controller;
IsActive = true;
CheckCasting = true;
Selectable = true;
CachedGameObject.SetActiveIfNot(true);
if (Body.IsNotNull())
{
Body.Initialize(new Vector2dHeight(position), rotation);
}
if (Triggers.IsNotNull())
{
foreach (LSTrigger trigger in Triggers)
{
trigger.Initialize();
}
}
if (Influencer.IsNotNull())
{
Influencer.Initialize();
}
if (Animator.IsNotNull())
{
Animator.Initialize();
}
abilityManager.Initialize();
}
public static void ChangeController(LSAgent agent, AgentController newCont)
{
AgentController leController = agent.Controller;
leController.LocalAgentActive [agent.LocalID] = false;
GlobalAgentActive[agent.GlobalID] = false;
leController.OpenLocalIDs.Add(agent.LocalID);
OpenGlobalIDs.Add(agent.GlobalID);
if (newCont == null)
{
agent.InitializeController(null, 0, 0);
}
else
{
agent.Influencer.Deactivate();
newCont.AddAgent(agent);
agent.Influencer.Initialize();
}
}
public static void Deactivate()
{
for (int i = 0; i < PeakGlobalID; i++)
{
if (GlobalAgentActive [i])
{
DestroyAgent(GlobalAgents [i], true);
}
}
CheckDestroyAgent();
for (int i = 0; i < DeathingAgents.PeakCount; i++)
{
if (DeathingAgents.arrayAllocation [i])
{
LSAgent agent = DeathingAgents [i];
AgentController.CompleteLife(agent);
}
}
DeathingAgents.FastClear();
}
public static void Deactivate()
{
if (Started == false)
{
return;
}
Selector.Clear();
AgentController.Deactivate();
BehaviourHelper.GlobalDeactivate();
ProjectileManager.Deactivate();
ClientManager.Deactivate();
foreach (LSManager manager in Managers)
{
manager.Deactivate();
}
TeamManager.Deactivate();
ClientManager.NetworkHelper.Disconnect();
Started = false;
}
public static void Simulate()
{
if (InfluenceCount == 0)
{
InfluenceSimulate();
InfluenceCount = InfluenceResolution - 1;
if (FrameManager.CanAdvanceFrame == false)
{
Stalled = true;
return;
}
Stalled = false;
FrameManager.Simulate();
InfluenceFrameCount++;
}
else
{
InfluenceCount--;
}
if (Stalled)
{
return;
}
if (FrameCount == 0)
{
StartGame();
}
BehaviourHelper.GlobalSimulate();
AgentController.Simulate();
PhysicsManager.Simulate();
CoroutineManager.Simulate();
InfluenceManager.Simulate();
ProjectileManager.Simulate();
TestManager.Simulate();
TeamManager.Simulate();
LateSimulate();
FrameCount++;
}
protected override void OnLateApply()
{
foreach (EnvironmentBodyInfo info in EnvironmentBodies)
{
info.Body.Initialize(info.Position, info.Rotation);
}
foreach (EnvironmentObject obj in EnvironmentObjects)
{
obj.LateInitialize();
}
var environmentController = AgentControllerHelper.Instance.GetInstanceManager(AgentControllerHelper.Instance.EnvironmentController);
foreach (var agentInfo in EnvironmentAgents)
{
var agent = agentInfo.Agent;
agentInfo.Agent.Setup(AgentController.GetAgentInterfacer(agentInfo.AgentCode));
environmentController.InitializeAgent(agent, agentInfo.Position.ToVector2d(), agentInfo.Rotation);
agentInfo.Agent.Body.HeightPos = agentInfo.Position.z;
agentInfo.Agent.TypeIndex = AgentController.UNREGISTERED_TYPE_INDEX;
}
}
internal static void Deactivate()
{
DefaultMessageRaiser.EarlyDeactivate();
if (GameStarted == false)
{
return;
}
Selector.Clear();
AgentController.Deactivate();
BehaviourHelperManager.Deactivate();
ProjectileManager.Deactivate();
EffectManager.Deactivate();
ClientManager.Deactivate();
ClientManager.Quit();
PhysicsManager.Deactivate();
GameStarted = false;
LSServer.Deactivate();
DefaultMessageRaiser.LateDeactivate();
CoroutineManager.Deactivate();
}
internal static void Deactivate()
{
DefaultMessageRaiser.EarlyDeactivate();
if (Started == false)
{
return;
}
Selector.Clear();
AgentController.Deactivate();
MainGameManager.MainInterfacingHelper.Deactivate();
BehaviourHelperManager.Deactivate();
ProjectileManager.Deactivate();
ClientManager.Deactivate();
LockstepManager.Deactivate();
TeamManager.Deactivate();
ClientManager.NetworkHelper.Disconnect();
Started = false;
DefaultMessageRaiser.LateDeactivate();
}
/// <summary>
/// Sends the command for all AgentControllers under the control of this PlayerManager...
/// Mainly for shared control capabilities
/// </summary>
/// <param name="com">COM.</param>
public static void SendCommand(Command com)
{
com.Add <Selection>(new Selection());
for (int i = 0; i < AgentControllers.Count; i++)
{
AgentController cont = AgentControllers[i];
if (cont.SelectedAgents.Count > 0)
{
com.ControllerID = cont.ControllerID;
if (cont.SelectionChanged)
{
com.SetData <Selection>(new Selection(cont.SelectedAgents));
cont.SelectionChanged = false;
}
else
{
com.ClearData <Selection> ();
}
CommandManager.SendCommand(com);
}
}
}
public static void RemoveController(AgentController agentController)
{
Selector.Clear();
AgentControllers.RemoveAt(agentController.PlayerIndex);
if (MainController == agentController)
{
if (AgentControllers.Count == 0)
{
MainController = null;
}
else
{
for (int i = 0; i < AgentControllers.PeakCount; i++)
{
if (AgentControllers.arrayAllocation [i])
{
MainController = AgentControllers [i];
break;
}
}
}
}
}
public static void SendCommand(Command com)
{
com.Select = new Selection();
for (int i = 0; i < AgentControllers.Count; i++)
{
AgentController cont = AgentControllers[i];
if (cont.SelectedAgents.Count > 0)
{
if (cont.SelectionChanged)
{
com.Select = new Selection(cont.SelectedAgents);
cont.SelectionChanged = false;
}
else
{
com.HasSelect = false;
}
com.ControllerID = cont.ControllerID;
com.Select.Serialize(AgentControllers[i].SelectedAgents);
CommandManager.SendCommand(com);
}
}
}
public static void RegisterRawAgent(LSAgent agent)
{
var agentCodeID = AgentController.GetAgentCodeIndex(agent.MyAgentCode);
FastList <bool> typeActive;
if (!AgentController.TypeAgentsActive.TryGetValue(agentCodeID, out typeActive))
{
typeActive = new FastList <bool> ();
TypeAgentsActive.Add(agentCodeID, typeActive);
}
FastList <LSAgent> typeAgents;
if (!TypeAgents.TryGetValue(agentCodeID, out typeAgents))
{
typeAgents = new FastList <LSAgent> ();
TypeAgents.Add(agentCodeID, typeAgents);
}
//TypeIndex of ushort.MaxValue means that this agent isn't registered for the pool
agent.TypeIndex = (ushort)(typeAgents.Count);
typeAgents.Add(agent);
typeActive.Add(true);
}
public static void Setup()
{
UnityInstance = GameObject.CreatePrimitive(PrimitiveType.Sphere).AddComponent <MonoBehaviour> ();
UnityInstance.GetComponent <Renderer>().enabled = false;
GameObject.DontDestroyOnLoad(UnityInstance.gameObject);
AbilityInterfacer.Setup();
AgentController.Setup();
TeamManager.Setup();
ProjectileManager.Setup();
EffectManager.Setup();
BehaviourHelper.GlobalSetup();
PhysicsManager.Setup();
ClientManager.Setup(MainGameManager.MainNetworkHelper);
InterfaceManager.Setup();
Application.targetFrameRate = 30;
Time.fixedDeltaTime = BaseDeltaTime;
Time.maximumDeltaTime = Time.fixedDeltaTime * 2;
InputManager.Setup();
}
protected override void OnExecute(Command com)
{
Agent.StopCast(this.ID);
Vector2d pos;
DefaultData target;
if (com.TryGetData <Vector2d>(out pos) && CanMove)
{
if (HasTarget)
{
cachedMove.RegisterGroup(false);
}
else
{
cachedMove.RegisterGroup();
}
isAttackMoving = true;
isFocused = false;
}
else if (com.TryGetData <DefaultData>(out target) && target.Is(DataType.UShort))
{
isFocused = true;
isAttackMoving = false;
LSAgent tempTarget;
ushort targetValue = (ushort)target.Value;
if (AgentController.TryGetAgentInstance(targetValue, out tempTarget))
{
Engage(tempTarget);
}
else
{
Debug.Log("nope");
}
}
}
public void AddController(AgentController controller)
{
controller.JoinTeam(this);
}
public AttackerInfo(LSAgent attacker, AgentController controller)
{
Attacker = attacker;
Controller = controller;
}
private static void UpdateDiplomacy(AgentController newCont)
{
for (int i = 0; i < InstanceManagers.Count; i++) {
InstanceManagers[i].DiplomacyFlags.AddAt (AllegianceType.Neutral,newCont.ControllerID);
}
}
public void SetAllegiance(AgentController otherController, AllegianceType allegianceType)
{
DiplomacyFlags[otherController.ControllerID] = allegianceType;
}
public static void Initialize()
{
MainController = null;
AgentControllers.FastClear();
}
//Backward compat.
public static Command GenerateSpawnCommand(AgentController cont, string agentCode, int count, Vector2d position)
{
return(Lockstep.Example.ExampleSpawner.GenerateSpawnCommand(cont, agentCode, count, position));
}
public static void Update()
{
MousePosition = Input.mousePosition;
MouseWorldPosition = GetWorldPos(MousePosition);
CanClearSelection = !Input.GetKey(KeyCode.LeftShift);
GetMousedAgent();
if (Boxing)
{
BoxingTime += Time.deltaTime;
if (MousePosition != BoxEnd)
{
Vector2 RaycastTopLeft;
Vector2 RaycastTopRight;
Vector2 RaycastBotLeft;
Vector2 RaycastBotRight;
BoxEnd = MousePosition;
if (BoxStart.x < BoxEnd.x)
{
RaycastTopLeft.x = BoxStart.x;
RaycastBotLeft.x = BoxStart.x;
RaycastTopRight.x = BoxEnd.x;
RaycastBotRight.x = BoxEnd.x;
}
else
{
RaycastTopLeft.x = BoxEnd.x;
RaycastBotLeft.x = BoxEnd.x;
RaycastTopRight.x = BoxStart.x;
RaycastBotRight.x = BoxStart.x;
}
if (BoxStart.y < BoxEnd.y)
{
RaycastBotLeft.y = BoxStart.y;
RaycastBotRight.y = BoxStart.y;
RaycastTopLeft.y = BoxEnd.y;
RaycastTopRight.y = BoxEnd.y;
}
else
{
RaycastBotLeft.y = BoxEnd.y;
RaycastBotRight.y = BoxEnd.y;
RaycastTopLeft.y = BoxStart.y;
RaycastTopRight.y = BoxStart.y;
}
Box_TopLeft = GetWorldPos(RaycastTopLeft);
Box_TopRight = GetWorldPos(RaycastTopRight);
Box_BottomLeft = GetWorldPos(RaycastBotLeft);
Box_BottomRight = GetWorldPos(RaycastBotRight);
}
ClearBox();
int lecount = 0;
if ((BoxEnd - BoxStart).sqrMagnitude >= MinBoxSqrDist)
{
for (i = 0; i < PlayerManager.agentControllers.Count; i++)
{
AgentController agentController = PlayerManager.agentControllers [i];
for (j = 0; j < AgentController.MaxAgents; j++)
{
if (agentController.AgentActive [j])
{
curAgent = agentController.Agents [j];
if (curAgent.cachedRenderer.isVisible)
{
Vector2 agentPos = new Vector2(curAgent.transform.position.x, curAgent.transform.position.z);
Edge = Box_TopRight - Box_TopLeft;
Point = agentPos - Box_TopLeft;
if (DotEdge() < 0)
{
Edge = Box_BottomRight - Box_TopRight;
Point = agentPos - Box_TopRight;
if (DotEdge() < 0)
{
Edge = Box_BottomLeft - Box_BottomRight;
Point = agentPos - Box_BottomRight;
if (DotEdge() < 0)
{
Edge = Box_TopLeft - Box_BottomLeft;
Point = agentPos - Box_BottomLeft;
if (DotEdge() < 0)
{
BoxAgent(curAgent);
continue;
}
}
}
}
}
if (curAgent.BoxVersion == BoxedAgents._BufferVersion)
{
curAgent.IsHighlighted = false;
}
}
}
}
}
if (Input.GetMouseButtonUp(0))
{
if (CanClearSelection)
{
ClearSelection();
}
SelectBoxedAgents();
SelectAgent(MousedAgent);
Boxing = false;
}
}
else
{
if (Input.GetMouseButtonDown(0))
{
CheckBoxDistance = true;
Boxing = true;
BoxingTime = 0f;
BoxStart = MousePosition;
BoxEnd = MousePosition;
}
}
}
public void AddController(AgentController controller)
{
controller.JoinTeam (this);
}
public AllegianceType GetAllegiance(AgentController controller)
{
return GetAllegiance (controller.MyTeam);
}
internal void InitializeController(AgentController controller, ushort localID, ushort globalID)
{
this.Controller = controller;
this.LocalID = localID;
this.GlobalID = globalID;
}
public AllegianceType GetAllegiance(AgentController controller)
{
return(GetAllegiance(controller.MyTeam));
}
public static AllegianceType GetAllegiance(AgentController otherController)
{
if (Selector.MainSelectedAgent != null) return Selector.MainSelectedAgent.Controller.GetAllegiance(otherController);
if (MainController == null) return AllegianceType.Neutral;
return MainController.GetAllegiance (otherController);
}
public AllegianceType GetAllegiance(AgentController otherController)
{
return HasTeam && otherController.HasTeam ? MyTeam.GetAllegiance (otherController) : DiplomacyFlags[otherController.ControllerID];
}
public static bool ContainsController(AgentController controller)
{
return controller.PlayerIndex < AgentControllers.PeakCount && AgentControllers[controller.PlayerIndex] == controller;
}
public static void OrderSpawn(AgentController cont, AgentCode agentCode, int count, Vector2d position)
{
Command com = new Command (InputCode.Spawn);
com.ControllerID = cont.ControllerID;
com.Position = position;
com.Target = (ushort)agentCode;
com.Count = count;
CommandManager.SendCommand(com);
}
private static void LateSimulate()
{
BehaviourHelper.GlobalLateSimulate();
AgentController.LateSimulate();
PhysicsManager.LateSimulate();
}
public AllegianceType GetAllegiance(AgentController otherController)
{
return(HasTeam && otherController.HasTeam ? MyTeam.GetAllegiance(otherController) : DiplomacyFlags [otherController.ControllerID]);
}
public static void AddController(AgentController agentController)
{
agentController.PlayerIndex = AgentControllers.Add(agentController);
if (MainController == null) MainController = agentController;
}
public static void Simulate()
{
if (FreeSimulate)
return;
TweakFramerate();
ForeSight--;
Frame frame = frames [LockstepManager.InfluenceFrameCount];
if (frame.Commands .IsNotNull())
{
for (int i = 0; i < frame.Commands.Count; i++)
{
Command com = frame.Commands [i];
switch (com.LeInput)
{
case InputCode.Meta:
MetaActionCode actionCode = (MetaActionCode)com.Target;
int id = com.Count;
switch (actionCode)
{
case MetaActionCode.NewPlayer:
AgentController controller = new AgentController();
if (id == ClientManager.ID)
{
PlayerManager.AddController(controller);
}
TeamManager.JoinTeam(controller);
break;
}
break;
default:
AgentController cont = AgentController.InstanceManagers [com.ControllerID];
cont.Execute(com);
break;
}
}
}
if (LockstepManager.InfluenceFrameCount == EndFrame)
{
FreeSimulate = true;
}
}
private void SerializeAgent(LSAgent agent)
{
if (leAgentController == null) {
leAgentController = agent.Controller;
}
bigIndex = (agent.LocalID / 8);
smallIndex = (agent.LocalID % 8);
Header |= (ulong)1 << bigIndex;
Data[bigIndex] |= (byte)(1 << smallIndex);
selectedAgentLocalIDs.Add (agent.LocalID);
}
public static AgentController Create()
{
AgentController controller = new AgentController();
controller.InitializeLocal ();
return controller;
}
public static bool ContainsController(AgentController controller)
{
return(controller.PlayerIndex < AgentControllers.PeakCount && AgentControllers.ContainsAt(controller.PlayerIndex, controller));
}
