protected override void OnInitialize()
{
basePriority = Agent.Body.Priority;
searchCount = LSUtility.GetRandom(SearchRate) + 1;
attackCount = 0;
Target = null;
IsAttackMoving = false;
inRange = false;
isFocused = false;
CycleCount = 0;
this.Destination = Vector2d.zero;
repathTimer.Reset(repathInterval);
repathRandom = LSUtility.GetRandom(repathInterval);
//caching parameters
var spawnVersion = Agent.SpawnVersion;
var controller = Agent.Controller;
CachedOnHit = (target) => OnHit(target, spawnVersion, controller);
if ((Agent as RTSAgent).GetCommander() && loadedSavedValues && loadedTargetId >= 0)
{
RTSAgent obj = (Agent as RTSAgent).GetCommander().GetObjectForId(loadedTargetId);
if (obj.MyAgentType == AgentType.Unit || obj.MyAgentType == AgentType.Building)
{
Target = (LSAgent)obj;
}
}
}
static IEnumerator send(byte[] data)
{
yield return(LSUtility.WaitRealTime(UnityEngine.Random.Range(Latency, Latency + Jitter)));
ClientManager.HandleFrameData(data);
yield break;
}
protected override void OnInitialize()
{
basePriority = Agent.Body.Priority;
constructCount = 0;
CurrentProject = null;
IsBuilding = false;
IsBuildMoving = false;
inRange = false;
IsFocused = false;
repathTimer.Reset(repathInterval);
repathRandom = LSUtility.GetRandom(repathInterval);
//caching parameters
var spawnVersion = Agent.SpawnVersion;
var controller = Agent.Controller;
if (Agent.GetCommander() && loadedSavedValues && loadedProjectId >= 0)
{
RTSAgent obj = Agent.GetCommander().GetObjectForId(loadedProjectId);
if (obj.MyAgentType == AgentType.Building)
{
CurrentProject = obj;
}
}
}
static IEnumerator receive(byte[] data)
{
yield return(LSUtility.WaitRealTime(UnityEngine.Random.Range(Latency, Latency + Jitter)));
receivedBytes.AddRange(data);
yield break;
}
protected override void OnInitialize()
{
basePriority = Agent.Body.Priority;
harvestCount = 0;
IsHarvesting = false;
IsHarvestMoving = false;
inRange = false;
IsFocused = false;
repathTimer.Reset(repathInterval);
repathRandom = LSUtility.GetRandom(repathInterval);
//caching parameters
var spawnVersion = Agent.SpawnVersion;
var controller = Agent.Controller;
if (Agent.GetCommander() && loadedSavedValues && loadedDepositId >= 0)
{
RTSAgent obj = Agent.GetCommander().GetObjectForId(loadedDepositId);
if (obj.MyAgentType == AgentType.Resource)
{
resourceTarget = obj;
}
}
else
{
HarvestType = ResourceType.Unknown;
}
}
public virtual void OnInitialize()
{
cachedBody = cachedAgent.Body;
cachedHealth = cachedAgent.GetAbility <Health>();
cachedMove = cachedAgent.GetAbility <Move>();
cachedTurn = cachedAgent.GetAbility <Turn>();
searchCount = LSUtility.GetRandom(SearchRate) + 1;
}
internal static void Initialize(ILockstepEventsHandler[] helpers, NetworkHelper networkHelper)
{
PlayRate = FixedMath.One;
//PauseCount = 0;
if (!Loaded)
{
Setup();
Loaded = true;
}
DefaultMessageRaiser.EarlyInitialize();
LSDatabaseManager.Initialize();
LSUtility.Initialize(1);
InfluenceCount = 0;
Time.timeScale = 1f;
Stalled = true;
FrameCount = 0;
InfluenceFrameCount = 0;
MainNetworkHelper = networkHelper;
AgentController.Initialize();
ClientManager.Initialize(MainNetworkHelper);
BehaviourHelperManager.Initialize(helpers);
GridManager.Initialize();
CoroutineManager.Initialize();
FrameManager.Initialize();
CommandManager.Initialize();
PhysicsManager.Initialize();
PlayerManager.Initialize();
// GridBuilder.Initialize();
//Initialized in UserInputHelper
// SelectionManager.Initialize ();
InfluenceManager.Initialize();
ProjectileManager.Initialize();
DefaultMessageRaiser.LateInitialize();
BehaviourHelperManager.LateInitialize();
if (onInitialize != null)
{
onInitialize();
}
}
public static int GetStateHash()
{
int hash = LSUtility.PeekRandom(int.MaxValue);
hash += 1;
hash ^= AgentController.GetStateHash();
hash += 1;
hash ^= ProjectileManager.GetStateHash();
hash += 1;
return(hash);
}
static IEnumerator Tick()
{
while (true)
{
if (IsSimulating && LockstepManager.GameStarted)
{
bufferBytes.FastClear();
bufferBytes.AddRange(BitConverter.GetBytes(InfluenceFrameCount));
InfluenceFrameCount++;
bufferBytes.AddRange(receivedBytes);
receivedBytes.FastClear();
Send(bufferBytes.ToArray());
}
yield return(LSUtility.WaitRealTime(LockstepManager.DeltaTimeF * LockstepManager.InfluenceResolution));
}
}
public static Vector2d GenerateRandomPointOnCircle(bool evenDistribution = false)
{
long angle = LSUtility.GetRandomOne().Mul(FixedMath.TwoPi);
long distance = LSUtility.GetRandomOne();
if (evenDistribution)
{
distance = FixedMath.Sqrt(distance);
}
Vector2d randomOffset = new Vector2d(
FixedMath.Trig.Cos(angle),
FixedMath.Trig.Sin(angle)
) * distance;
return(randomOffset);
}
public static int GetStateHash()
{
int operationToggle = 0;
int hash = LSUtility.PeekRandom(int.MaxValue);
for (int i = 0; i < PeakGlobalID; i++)
{
if (GlobalAgentActive[i])
{
RTSAgent agent = GlobalAgents[i];
int n1 = agent.Body._position.GetHashCode() + agent.Body._rotation.GetHashCode();
switch (operationToggle)
{
case 0:
hash ^= n1;
break;
case 1:
hash += n1;
break;
default:
hash ^= n1 * 3;
break;
}
operationToggle++;
if (operationToggle >= 2)
{
operationToggle = 0;
}
}
}
return(hash);
}
private void DistributeCollision()
{
if (!DoPhysics)
{
return;
}
switch (LeCollisionType)
{
case CollisionType.Circle_Circle:
DistX = Body1._position.x - Body2._position.x;
DistY = Body1._position.y - Body2._position.y;
dist = FixedMath.Sqrt((DistX * DistX + DistY * DistY) >> FixedMath.SHIFT_AMOUNT);
if (dist == 0)
{
//If objects are on the same position, give them push in random direction
const long randomMax = FixedMath.One / 32;
Body1._position.x += LSUtility.GetRandomLong(randomMax) - randomMax / 2;
Body1._position.y += LSUtility.GetRandomLong(randomMax) - randomMax / 2;
Body1.PositionChanged = true;
Body2._position.x += LSUtility.GetRandomLong(randomMax) - randomMax / 2;
Body2._position.y += LSUtility.GetRandomLong(randomMax) - randomMax / 2;
Body2.PositionChanged = true;
return;
}
depth = (Body1.Radius + Body2.Radius - dist);
if (depth <= 0)
{
return;
}
DistX = (DistX * depth / dist);
DistY = (DistY * depth / dist);
//Resolving collision
if (Body1.Immovable || (Body2.Immovable == false && Body1.Priority > Body2.Priority))
{
DistX *= -1;
DistY *= -1;
DistributeCircle_CirclePriority(Body1, Body2);
}
else if (Body2.Immovable || Body2.Priority > Body1.Priority)
{
DistributeCircle_CirclePriority(Body2, Body1);
}
else
{
DistX /= 2;
DistY /= 2;
DistributeCircle(Body1);
DistX *= -1;
DistY *= -1;
DistributeCircle(Body2);
}
break;
case CollisionType.Circle_AABox:
if (Body1.Shape == ColliderType.AABox)
{
DistributeCircle_Box(Body1, Body2);
}
else
{
DistributeCircle_Box(Body2, Body1);
}
break;
case CollisionType.Circle_Polygon:
if (Body1.Shape == ColliderType.Circle)
{
this.DistributeCircle_Poly(Body1, Body2);
}
else
{
this.DistributeCircle_Poly(Body2, Body1);
}
break;
}
}
// public static string[] AvatarCodes;
#endregion
#region MonoBehavior
public static void Setup()
{
IAgentDataProvider agentDatabase;
if (LSDatabaseManager.TryGetDatabase <IAgentDataProvider>(out agentDatabase))
{
AgentData = agentDatabase.AgentData;
AgentCodes = new string[AgentData.Length];
AgentController.CachedAgents = new Dictionary <string, FastStack <LSAgent> >(AgentData.Length);
OrganizerObject = LSUtility.CreateEmpty().transform;
OrganizerObject.gameObject.name = "OrganizerObject";
OrganizerObject.gameObject.SetActive(false);
GameObject.DontDestroyOnLoad(OrganizerObject);
for (int i = 0; i < AgentData.Length; i++)
{
IAgentData interfacer = AgentData[i];
string agentCode = interfacer.Name;
AgentCodes[i] = agentCode;
AgentController.CachedAgents.Add(agentCode, new FastStack <LSAgent>(2));
AgentCodeInterfacerMap.Add(agentCode, interfacer);
AgentCodeIndexMap.Add(agentCode, (ushort)i);
}
}
else
{
Debug.Log("Database does not provide AgentData. Make sure it implements IAgentDataProvider.");
}
IWorldObjectDataProvider worldObjectDatabase;
if (LSDatabaseManager.TryGetDatabase <IWorldObjectDataProvider>(out worldObjectDatabase))
{
WorldObjectData = worldObjectDatabase.WorldObjectData;
WorldObjectCodes = new string[AgentData.Length];
for (int i = 0; i < WorldObjectData.Length; i++)
{
IWorldObjectData interfacer = WorldObjectData[i];
string worldObjectCode = interfacer.Name;
WorldObjectCodes[i] = worldObjectCode;
WorldObjectCodeInterfacerMap.Add(worldObjectCode, interfacer);
}
}
else
{
Debug.Log("Database does not provide WorldObjectData. Make sure it implements IWorldObjectDataProvider.");
}
IAvatarDataProvider avatarDatabase;
if (LSDatabaseManager.TryGetDatabase <IAvatarDataProvider>(out avatarDatabase))
{
AvatarData = avatarDatabase.AvatarData;
Avatars = new Texture2D[AvatarData.Length];
for (int i = 0; i < AvatarData.Length; i++)
{
IAvatarData interfacer = AvatarData[i];
Texture2D avatar = interfacer.GetAvatar();
// AvatarCodes[i] = avatarCode;
Avatars[i] = avatar;
// AvatarCodeInterfacerMap.Add(avatarCode, interfacer);
}
}
else
{
Debug.Log("Database does not provide WorldObjectData. Make sure it implements IWorldObjectDataProvider.");
}
}