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);