public override int GetHashCode()
        {
            int hash = 1;

            if (Died != false)
            {
                hash ^= Died.GetHashCode();
            }
            if (Respawned != false)
            {
                hash ^= Respawned.GetHashCode();
            }
            if (decision_ != null)
            {
                hash ^= Decision.GetHashCode();
            }
            hash ^= path_.GetHashCode();
            if (HatChanged != false)
            {
                hash ^= HatChanged.GetHashCode();
            }
            if (ClothesChanged != false)
            {
                hash ^= ClothesChanged.GetHashCode();
            }
            if (ShoesChanged != false)
            {
                hash ^= ShoesChanged.GetHashCode();
            }
            if (WeaponChanged != false)
            {
                hash ^= WeaponChanged.GetHashCode();
            }
            if (AccessoryChanged != false)
            {
                hash ^= AccessoryChanged.GetHashCode();
            }
            hash ^= attackLocations_.GetHashCode();
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
 public static void Respawn()
 {
     Respawned?.Invoke();
 }
Beispiel #3
0
 private void OnRespawned()
 {
     Respawned?.Invoke(this, EventArgs.Empty);
 }
Beispiel #4
0
 private void Respawn()
 {
     DeathScreen.SetActive(false);
     Respawned?.Invoke();
 }
Beispiel #5
0
        public void Respawn( )
        {
            var p = Test.DataUtils.GetZone(448).POIs["watchtower"];

            CharacterEntity.Position = p;

            var forcedMove = new ForcedMovement {
                Type         = 1,
                Unk1         = 0,
                Position     = p,
                AimDirection = CharacterEntity.AimDirection,
                Velocity     = Vector3.Zero,
                GameTime     = AssignedShard.CurrentTime,
                KeyFrame     = AssignedShard.CurrentShortTime
            };

            NetChans[ChannelType.ReliableGss].SendGSSClass(forcedMove, CharacterEntity.EntityID);

            var respawnMsg = new Respawned {
                LastUpdateTime = AssignedShard.CurrentTime - 2,
                Unk1           = 0x0100
            };

            NetChans[ChannelType.ReliableGss].SendGSSClass(respawnMsg, CharacterEntity.EntityID);

            var upd = new PartialUpdate();

            upd.Add(new MovementView {
                LastUpdateTime = AssignedShard.CurrentTime,
                Position       = CharacterEntity.Position,
                Rotation       = CharacterEntity.Rotation,
                AimDirection   = CharacterEntity.AimDirection,
                Velocity       = CharacterEntity.Velocity,
                State          = (ushort)CharacterEntity.MovementState,
                Unk1           = 0,
                Jets           = (ushort)CharacterEntity.CharData.JumpJetEnergy,
                AirGroundTimer = 0x3a7f,
                JumpTimer      = 0x3cdb,
                Unk2           = 0,
            });

            upd.Add(new CharacterState {
                State          = 3,
                LastUpdateTime = AssignedShard.CurrentTime - 1,
            });

            upd.Add(new Unknown1 {
            });

            upd.Add(new Unknown2 {
                Unk1           = 0x0100,
                Unk2           = 0x0100,
                LastUpdateTime = AssignedShard.CurrentTime,
            });

            NetChans[ChannelType.ReliableGss].SendGSSClass(upd, CharacterEntity.EntityID, Enums.GSS.Controllers.Character_BaseController);

            upd = new PartialUpdate();

            upd.Add(new Unknown3 {
                Unk1           = 0,
                LastUpdateTime = AssignedShard.CurrentTime,
            });

            upd.Add(new CharacterState {
                State          = 6,
                LastUpdateTime = AssignedShard.CurrentTime,
            });

            upd.Add(new CurrentHealth {
                Value = CharacterEntity.CharData.MaxHealth,
            });

            upd.Add(new Unknown4 {
                Unk1 = 0
            });

            upd.Add(new Unknown1 {
            });

            NetChans[ChannelType.ReliableGss].SendGSSClass(upd, CharacterEntity.EntityID, Enums.GSS.Controllers.Character_BaseController);

            upd = new PartialUpdate();

            upd.Add(new Unknown5 {
                LastUpdateTime = AssignedShard.CurrentTime,
            });

            NetChans[ChannelType.ReliableGss].SendGSSClass(upd, CharacterEntity.EntityID, Enums.GSS.Controllers.Character_BaseController);
        }
Beispiel #6
0
        static LocalVehicle()
        {
            Screen = new Screen();
            HUD    = new HUD();

            Events.Car.PreExplode.SubscribeAll((sender, data) =>
            {
                BeforeExploded?.Invoke(null, System.EventArgs.Empty);
            });

            Events.Car.PreSplit.SubscribeAll((sender, data) =>
            {
                BeforeSplit?.Invoke(null, System.EventArgs.Empty);
            });

            Events.Car.CheckpointHit.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new CheckpointHitEventArgs(data.checkpointIndex_, data.trackT_);
                    CheckpointPassed?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Death.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new DestroyedEventArgs((DestructionCause)data.causeOfDeath);
                    Destroyed?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Explode.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new DestroyedEventArgs((DestructionCause)data.causeOfDeath);
                    Exploded?.Invoke(null, eventArgs);
                }
            });

            Events.RaceEnd.LocalCarHitFinish.Subscribe(data =>
            {
                BeforeFinished?.Invoke(null, System.EventArgs.Empty);
            });

            Events.Player.Finished.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>() != null)
                {
                    var eventArgs = new FinishedEventArgs((RaceEndType)data.finishType_, data.finishData_);
                    Finished?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Horn.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new HonkEventArgs(data.hornPercent_, new Position(data.position_.x, data.position_.y, data.position_.z));
                    Honked?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Impact.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new ImpactEventArgs(data.speed_, new Position(data.pos_.x, data.pos_.y, data.pos_.z), data.impactedCollider_.name);
                    Collided?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Jump.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    Jumped?.Invoke(null, System.EventArgs.Empty);
                }
            });

            Events.Car.ModeSpecial.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    SpecialModeEvent?.Invoke(null, System.EventArgs.Empty);
                }
            });

            Events.Player.CarRespawn.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>() != null)
                {
                    var pos       = new Position(data.position_.x, data.position_.y, data.position_.z);
                    var rot       = new Rotation(data.rotation_.x, data.rotation_.y, data.rotation_.z);
                    var eventArgs = new RespawnEventArgs(pos, rot, data.fastRespawn_);

                    Respawned?.Invoke(null, eventArgs);
                }
            });

            Events.Car.Split.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new SplitEventArgs(data.penetration, data.separationSpeed);
                    Split?.Invoke(null, eventArgs);
                }
            });

            Events.Car.TrickComplete.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    var eventArgs = new TrickCompleteEventArgs(data.cooldownAmount_, data.points_, data.wallRideMeters_, data.ceilingRideMeters_, data.grindMeters_);
                    TrickCompleted?.Invoke(null, eventArgs);
                }
            });

            Events.Car.WingsStateChange.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    if (data.open_)
                    {
                        WingsOpened?.Invoke(null, System.EventArgs.Empty);
                    }
                    else
                    {
                        WingsClosed?.Invoke(null, System.EventArgs.Empty);
                    }
                }
            });

            Events.Car.WingsAbilityStateChanged.SubscribeAll((sender, data) =>
            {
                if (sender.GetComponent <PlayerDataLocal>())
                {
                    if (data.enabled_)
                    {
                        WingsEnabled?.Invoke(null, System.EventArgs.Empty);
                    }
                    else
                    {
                        WingsDisabled?.Invoke(null, System.EventArgs.Empty);
                    }
                }
            });
        }