public virtual void OnPostSimulate(int frameId, int subFrameId, bool isNetTick)
{
if (!IsMine)
{
return;
}
WeaponFrame frame = frames[frameId];
/// Clear the trigger mask for new frames
if (subFrameId == 0)
{
frame.Clear();
}
/// Process Fire
if (triggerQueued) //subFrameId < SimpleSyncSettings.sendEveryXTick)
{
frame.triggerMask |= (uint)1 << subFrameId;
Trigger(frame, subFrameId);
triggerQueued = false;
///TODO: is this needed?
frame.content = FrameContents.Complete;
}
}
public SerializationFlags OnNetDeserialize(int originFrameId, int localFrameId, byte[] buffer, ref int bitposition, FrameArrival arrival)
{
WeaponFrame frame = frames[localFrameId];
SerializationFlags flags = SerializationFlags.None;
if (buffer.ReadBool(ref bitposition))
{
frame.triggerMask = buffer.ReadUInt32(ref bitposition, sendEveryXTick);
flags |= SerializationFlags.HasChanged /*| SerializationFlags.ForceReliable*/;
}
else
{
frame.triggerMask = 0;
}
frame.hitmask = (uint)buffer.Read(ref bitposition, sendEveryXTick);
for (int i = 0; i < sendEveryXTick; ++i)
{
if ((frame.hitmask & (1 << i)) != 0)
{
flags |= frame.netHits[i].Deserialize(buffer, ref bitposition, NetObj.bitsForColliderIndex);
}
}
frame.content = flags == SerializationFlags.None ? FrameContents.Empty : FrameContents.Complete;
return(flags);
}
/// <summary>
/// Create the projectile instance
/// </summary>
protected override void Trigger(WeaponFrame frame, int subFrameId)
{
Pool p = Pool.Spawn(projPrefab, origin);
var ssproj = p.GetComponent <IProjectile>();
ssproj.Initialize(this, frame.frameId, subFrameId, velocity, terminateOn, damageOn);
ssproj.Owner = this;
}
protected override void PopulateFrames()
{
frames = new WeaponFrame[frameCount + 1];
for (int i = 0; i <= frameCount; ++i)
{
frames[i] = new WeaponFrame(this, false, i);
}
}
protected override void PopulateFrames()
{
frames = new WeaponFrame[frameCount + 1];
for (int i = 0; i <= frameCount; ++i)
{
frames[i] = new WeaponFrame(this, hitscanDefinition.nearestOnly, i);
}
}
/// <summary>
/// Calls the actual generic hitscan and gets the results. Results are stored to the frame.
/// </summary>
/// <param name="frame"></param>
protected override void Trigger(WeaponFrame frame, int subFrameId)
{
//Debug.Log(name + " Triggered");
NetworkHits results = frame.netHits[subFrameId];
List <NetworkHit> hits = results.hits;
hitscanDefinition.GenericHitscanNonAlloc(origin, ref hits, ref results.nearestIndex, Realm.Primary, visualizeHitscan);
HitsCallbacks(results);
//TriggerCosmetic();
}
private void HandleAnimation()
{
if (WeaponImage == null || CurrentFrameSet == null || CurrentFrameIndex >= CurrentFrameSet.Length)
{
//fail. Do nothing.
return;
}
TimeInFrame += Time.deltaTime / Timescale;
WeaponFrame currentFrame = CurrentFrameSet[CurrentFrameIndex];
if (TimeInFrame > currentFrame.Duration)
{
//advance to the next frame
CurrentFrameIndex++;
TimeInFrame = 0;
if (CurrentFrameIndex == CurrentFrameSet.Length)
{
//we were on the last frame and are now past the end
if (LoopIdle && (CurrentFrameSet == Idle || CurrentFrameSet == ADSIdle)) //loop
{
CurrentFrameIndex = 0;
}
else if (AutoTransition && CurrentFrameSet == Fire || CurrentFrameSet == Raise || CurrentFrameSet == Reload) //autotransition (non-ADS)
{
CurrentFrameSet = Idle;
CurrentFrameIndex = 0;
}
else if (AutoTransition && CurrentFrameSet == ADSFire || CurrentFrameSet == ADSRaise) //autotransition (ADS)
{
CurrentFrameSet = ADSIdle;
CurrentFrameIndex = 0;
}
else
{
return; //stop
}
}
SetImage(CurrentFrameSet, CurrentFrameIndex);
}
}
public override void OnPostSimulate(int frameId, int subFrameId, bool isNetTick)
{
/// Base handles the fire triggers. We hae special handling for hits, since they come in from the projectiles and are not instant
base.OnPostSimulate(frameId, subFrameId, isNetTick);
WeaponFrame frame = frames[frameId];
/// Owner log hits to frame/subframe
if (projectileHitQueue.Count > 0)
{
while (projectileHitQueue.Count > 0)
{
frame.netHits[subFrameId].hits.Add(projectileHitQueue.Dequeue());
}
frame.content = FrameContents.Complete;
frame.hitmask |= ((uint)1 << subFrameId);
HitsCallbacks(frame.netHits[subFrameId]);
}
}
public virtual SerializationFlags OnNetSerialize(int frameId, byte[] buffer, ref int bitposition, SerializationFlags writeFlags)
{
SerializationFlags flags = SerializationFlags.None;
/// TODO: Should be able to remove this dev check
if (!IsMine)
{
Debug.LogError(name + " Write but not ActingAuthority" + name + " " + frameId + " ismine:" + IsMine);
buffer.WriteBool(false, ref bitposition);
return(flags);
}
WeaponFrame frame = frames[frameId];
/// Serialize TriggerMask (each
if (frame.triggerMask != 0)
{
buffer.WriteBool(true, ref bitposition);
buffer.Write(frame.triggerMask, ref bitposition, sendEveryXTick);
flags = SerializationFlags.HasChanged /*| SerializationFlags.ForceReliable*/;
}
else
{
buffer.WriteBool(false, ref bitposition);
flags = SerializationFlags.None;
}
/// Serialize projectile hits TODO: give projectiles ids
buffer.Write(frame.hitmask, ref bitposition, sendEveryXTick);
for (int i = 0; i < sendEveryXTick; ++i)
{
if ((frame.hitmask & (1 << i)) != 0)
{
flags |= frame.netHits[i].Serialize(buffer, ref bitposition, NetObj.bitsForColliderIndex);
}
}
return(flags);
}
/// <summary> /// Instantiate the weapon graphic and hit tests code if applicable. Results should be stored to the frame. /// </summary> /// <param name="frame"></param> protected abstract void Trigger(WeaponFrame frame, int subFrameId);
