// TODO: Need to actually do Loading for cache "miss"
public MCgData LoadData(FECgAssetType assetType, string shortCode)
{
if (Map[assetType].ContainsKey(shortCode))
{
return(Map[assetType][shortCode]);
}
FCgDebug.LogWarning("MCgDataMapping.LoadData: No " + assetType.Name + " with ShortCode: " + shortCode);
return(null);
}
private bool ProcessRequest(FCgTraceRequest request)
{
/*
* if (CsCVarDrawManagerTraceRequests->GetInt() == CS_CVAR_DRAW)
* {
* // Sphere around Start
* DrawDebugSphere(GetWorld(), Request->Start, 16.0f, 16, FColor::Green, false, 0.1f, 0, 1.0f);
* // Line from Start to End
* DrawDebugLine(GetWorld(), Request->Start, Request->End, FColor::Red, false, 0.1f, 0, 1.0f);
* }
*/
request.bProcessing = true;
// Test (Check)
if (request.Method == ECgTraceMethod.Test)
{
FCgDebug.LogWarning("FCsManager_Trace.ProcessRequest: There is NO Async Trace " + request.Method.ToString() + " Method. Use TraceMethod: Single or Multi.");
request.Reset();
return(false);
}
// Line
if (request.Type == ECgTraceType.Line)
{
request.ScheduleCommand();
return(true);
}
// Sweep (Cast)
else
if (request.Type == ECgTraceType.Sweep)
{
FCgDebug.LogWarning("FCsManager_Trace.ProcessRequest: There is NO Async Sweep (Cast) Trace Method. Use TraceType: Line.");
request.Reset();
return(false);
}
// Overlap
else
if (request.Type == ECgTraceType.Overlap)
{
FCgDebug.LogWarning("FCsManager_Trace.ProcessRequest: There is NO Async Overlap (Cast) Trace Method. Use TraceType: Overlap.");
request.Reset();
return(false);
}
return(true);
}
public virtual void PlaySound(FECgWeaponFireMode fireMode, FECgWeaponSound soundType, MonoBehaviour owner, Vector3 location)
{
FCgSoundElement soundElement = GetSound(fireMode, soundType);
if (soundElement.Get() == null)
{
FCgDebug.LogWarning("MCsData_ProjectileWeapon.PlaySound: Attempting to Play a NULL Sound.");
return;
}
//ICgManager_Sound manager_sound = ICgManager_Sound.Get();
/*
* FCsSoundPayload* Payload = Manager_Sound->AllocatePayload();
* Payload->Set(SoundElement);
* Payload->Owner = InOwner;
* Payload->Location = Location;
*
* Manager_Sound->Play(Payload);
*/
}
public bool HasCompleted()
{
// Frame
// Time
if (bWaitForTime)
{
if (WaitForTimeType != null)
{
WaitForTime = WaitForTimeType.Get();
if (WaitForTime < 0.0f)
{
WaitForTime = 0.0f;
WaitForTimeType = null;
FCgDebug.LogWarning("FCgGizmoDrawRequest.HasCompleted: WaitForTimeType of type 'FCgGizmoDrawRequest.FTimeType' is used for WaitForTime. WaitForTimeType value must be >= 0.0f.");
}
}
return(WaitForTimeTimer >= WaitForTime);
}
// Flag
return(true);
}
public FCgTraceResponse Trace(FCgTraceRequest request)
{
request.StartTime = FCgManager_Time.Get().GetTimeSinceStart(TimeType);
bool addPending = !request.bForce && TraceCountThisFrame >= RequestsProcessedPerTick;
// TODO: Print warning for a normal trace moved to Async
if (addPending && !request.bAsync)
{
request.Reset();
FCgDebug.LogWarning("FCsManager_Trace.Trace: Reached maximum RequestsProcessedPerTick: " + RequestsProcessedPerTick + " and Request is NOT Async. Abandoning Request.");
return(null);
}
// Async
if (request.bAsync ||
addPending)
{
// if NOT Pending, Start Async
if (!addPending)
{
// if Successful in processing Request, EXIT
if (ProcessRequest(request))
{
AddPendingRequest(request);
IncrementTraceCount(request);
return(null);
}
}
// ADD Pending Request
AddPendingRequest(request);
return(null);
}
// Normal
else
{
#if UNITY_EDITOR
if (DrawRequests.Draw())
{
// Sphere around Start
FCgManager_GizmoDraw.Get().DrawSphere(request.Start, 0.16f, Color.green, 0.1f);
// Line from Start to End
FCgManager_GizmoDraw.Get().DrawLine(request.Start, request.End, Color.red, 0.1f);
}
#endif // #if UNITY_EDITOR
FCgTraceResponse response = AllocateResponse();
response.ElapsedTime = 0.0f;
// Line
if (request.Type == ECgTraceType.Line)
{
// Test
if (request.Method == ECgTraceMethod.Test)
{
// Linecast
response.bResult = Physics.Linecast(request.Start, request.End, request.LayerMask);
}
// Single
else
if (request.Method == ECgTraceMethod.Single)
{
FCgDebug.LogWarning("FCsManager_Trace.Trace: Line Trace Single is NOT supported. Use TraceMethod: Test or Multi. Abandoning Request.");
}
// Multi
else
if (request.Method == ECgTraceMethod.Multi)
{
// RaycastNonAlloc
Vector3 v = request.End - request.Start;
float distance = v.magnitude;
Vector3 dir = distance > 0.0f ? v / distance : Vector3.zero;
float EXTEND = 0.1f;
response.OutHitCount = Physics.RaycastNonAlloc(request.Start, dir, response.OutHitBuffer, distance + EXTEND, request.LayerMask);
response.ResolveHitBuffers(request.StartTime, request.Start, request.End);
}
}
// Sweep
else
if (request.Type == ECgTraceType.Sweep)
{
// Test
if (request.Method == ECgTraceMethod.Test)
{
// Box
if (request.Shape == ECgCollisionShape.Box)
{
// CheckBox
response.bResult = Physics.CheckBox(request.BoxParams.Center, request.BoxParams.HalfExtents, request.BoxParams.Orientation, request.LayerMask);
}
// Sphere
else
if (request.Shape == ECgCollisionShape.Sphere)
{
// CheckSphere
response.bResult = Physics.CheckSphere(request.SphereParams.Position, request.SphereParams.Radius, request.LayerMask);
}
// Capsule
else
if (request.Shape == ECgCollisionShape.Capsule)
{
// CheckCapsule
response.bResult = Physics.CheckCapsule(request.CapsuleParams.Start, request.CapsuleParams.End, request.CapsuleParams.Radius, request.LayerMask);
}
}
// Single
else
if (request.Method == ECgTraceMethod.Single)
{
FCgDebug.LogWarning("FCsManager_Trace.Trace: Sweep Trace Single is NOT supported. Use TraceMethod: Test or Multi. Abandoning Request.");
}
// Multi
else
if (request.Method == ECgTraceMethod.Multi)
{
// Box
if (request.Shape == ECgCollisionShape.Box)
{
// BoxCastNonAlloc
Vector3 v = request.End - request.Start;
float distance = v.magnitude;
Vector3 dir = distance > 0.0f ? v / distance : Vector3.zero;
float EXTEND = 0.1f;
response.OutHitCount = Physics.BoxCastNonAlloc(request.BoxParams.Center, request.BoxParams.HalfExtents, dir, response.OutHitBuffer, request.BoxParams.Orientation, distance + EXTEND, request.LayerMask);
response.ResolveHitBuffers(request.StartTime, request.Start, request.End);
}
// Sphere
else
if (request.Shape == ECgCollisionShape.Sphere)
{
// SphereCastNonAlloc
Vector3 v = request.End - request.Start;
float distance = v.magnitude;
Vector3 dir = distance > 0.0f ? v / distance : Vector3.zero;
float EXTEND = 0.1f;
response.OutHitCount = Physics.SphereCastNonAlloc(request.Start, request.SphereParams.Radius, dir, response.OutHitBuffer, distance + EXTEND, request.LayerMask);
response.ResolveHitBuffers(request.StartTime, request.Start, request.End);
}
// Capsule
else
if (request.Shape == ECgCollisionShape.Capsule)
{
// CapsuleCastNonAlloc
Vector3 v = request.End - request.Start;
float distance = v.magnitude;
Vector3 dir = distance > 0.0f ? v / distance : Vector3.zero;
float EXTEND = 0.1f;
response.OutHitCount = Physics.CapsuleCastNonAlloc(request.CapsuleParams.Start, request.CapsuleParams.End, request.CapsuleParams.Radius, dir, response.OutHitBuffer, distance + EXTEND, request.LayerMask);
response.ResolveHitBuffers(request.StartTime, request.Start, request.End);
}
}
}
// Overlap
else
if (request.Type == ECgTraceType.Overlap)
{
// Test
if (request.Method == ECgTraceMethod.Test)
{
FCgDebug.LogWarning("FCsManager_Trace.Trace: Overlap Trace Test is NOT supported. Use TraceMethod: Multi. Abandoning Request.");
}
// Single
else
if (request.Method == ECgTraceMethod.Single)
{
FCgDebug.LogWarning("FCsManager_Trace.Trace: Overlap Trace Single is NOT supported. Use TraceMethod: Multi. Abandoning Request.");
}
// Multi
else
if (request.Method == ECgTraceMethod.Multi)
{
// Box
if (request.Shape == ECgCollisionShape.Box)
{
// OverlapBoxNonAlloc
response.OutOverlapCount = Physics.OverlapBoxNonAlloc(request.BoxParams.Center, request.BoxParams.HalfExtents, response.OutOverlapBuffer, request.BoxParams.Orientation, request.LayerMask);
response.ResolveOverlapBuffers(request.StartTime);
}
// Sphere
else
if (request.Shape == ECgCollisionShape.Sphere)
{
// OverlapSphereNonAlloc
response.OutOverlapCount = Physics.OverlapSphereNonAlloc(request.SphereParams.Position, request.SphereParams.Radius, response.OutOverlapBuffer, request.LayerMask);
response.ResolveOverlapBuffers(request.StartTime);
}
// Capsule
else
if (request.Shape == ECgCollisionShape.Capsule)
{
// CapsuleCastNonAlloc
response.OutOverlapCount = Physics.OverlapCapsuleNonAlloc(request.CapsuleParams.Start, request.CapsuleParams.End, request.CapsuleParams.Radius, response.OutOverlapBuffer, request.LayerMask);
response.ResolveOverlapBuffers(request.StartTime);
}
}
}
IncrementTraceCount(request);
request.Reset();
#if UNITY_EDITOR
if (DrawResponses.Draw())
{
if (response.bResult)
{
// Sphere around Start
FCgManager_GizmoDraw.Get().DrawSphere(response.OutHits[FIRST].TraceStart, 0.16f, Color.green, 0.1f);
// Line from Start to End
FCgManager_GizmoDraw.Get().DrawLine(response.OutHits[FIRST].TraceStart, response.OutHits[FIRST].Location, Color.red, 0.1f);
}
}
#endif // #if UNITY_EDITOR
return(response);
}
}
private void OnBeginPlay_Handle_Pawns()
{
MCgPawn[] pawns = FindObjectsOfType <MCgPawn>();
foreach (MCgPawn p in pawns)
{
// Auto Possess
if (p.bAutoPossess)
{
bool possessed = false;
// Players
// Auto Assign Controller
if (p.ControllerIndex <= AUTO_ASSIGN_CONTROLLER)
{
foreach (MCgPlayerController pc in PlayerControllers)
{
if (pc.Pawn != null)
{
pc.Possess(p);
possessed = true;
break;
}
}
if (!possessed)
{
FCgDebug.LogWarning("MCgGameInstance.OnBeginPlay_Handle_Pawns: Failed to AutoPossess Pawn: " + p.name + " of type: " + p.GetType().ToString());
}
}
// Search for controller with matching index
else
{
if (p.ControllerIndex >= PlayerControllers.Count)
{
FCgDebug.LogWarning("MGgGameInstance.OnBeginPlay_Handle_Pawns: Failed to AutoPossess Pawn: " + p.name + " of type: " + p.GetType().ToString() + ". No PlayerController found with index: " + p.ControllerIndex);
}
else
{
int index = p.ControllerIndex;
if (PlayerControllers[index].Pawn != null)
{
FCgDebug.LogWarning("MGgGameInstance.OnBeginPlay_Handle_Pawns: Failed to AutoPossess Pawn: " + p.name + " of type: " + p.GetType().ToString());
FCgDebug.LogWarning("MGgGameInstance.OnBeginPlay_Handle_Pawns: PlayerController with index: " + index + " is already possessing Pawn: " + PlayerControllers[index].Pawn.name);
}
else
{
PlayerControllers[index].Possess(p);
}
}
}
// TODO: AI
}
p.bPlacedInWorld = true;
p.Init();
}
}
