示例#1
0
        public int Spawn(Edict pent)
        {
            var pEntity = pent.Entity();

            if (pEntity != null)
            {
                // Initialize these or entities who don't link to the world won't have anything in here
                pEntity.AbsMin = pEntity.Origin - new Vector(1, 1, 1);
                pEntity.AbsMax = pEntity.Origin + new Vector(1, 1, 1);

                pEntity.Spawn();

                // Try to get the pointer again, in case the spawn function deleted the entity.
                // UNDONE: Spawn() should really return a code to ask that the entity be deleted, but
                // that would touch too much code for me to do that right now.
                pEntity = pent.Entity();

                if (pEntity != null)
                {
                    if (!Engine.GameRules.IsAllowedToSpawn(pEntity))
                    {
                        return(-1);  // return that this entity should be deleted
                    }
                    if (0 != (pEntity.Flags & EntFlags.KillMe))
                    {
                        return(-1);
                    }
                }

                // Handle global stuff here
                if (pEntity != null && !string.IsNullOrEmpty(pEntity.GlobalName))
                {
                    var pGlobal = Globals.GlobalState.EntityFromTable(pEntity.GlobalName);
                    if (pGlobal != null)
                    {
                        // Already dead? delete
                        if (pGlobal.State == GlobalEState.Dead)
                        {
                            return(-1);
                        }
                        else if (Engine.Globals.MapName != pGlobal.LevelName)
                        {
                            pEntity.MakeDormant();  // Hasn't been moved to this level yet, wait but stay alive
                        }
                        // In this level & not dead, continue on as normal
                    }
                    else
                    {
                        // Spawned entities default to 'On'
                        Globals.GlobalState.EntityAdd(pEntity.GlobalName, Engine.Globals.MapName, GlobalEState.On);
                        //				Log.Alert(AlertType.Console, $"Added global entity {pEntity.ClassName} ({pEntity.GlobalName})\n");
                    }
                }
            }

            return(0);
            //TODO: define return codes
        }
示例#2
0
        public void Blocked(Edict pentBlocked, Edict pentOther)
        {
            var blocked = pentBlocked.Entity();

            var other = pentOther.Entity();

            blocked?.Blocked(other);
        }
示例#3
0
 public void OnFreeEntPrivateData(Edict pEnt)
 {
     if (pEnt.PrivateData != null)
     {
         //Inform of destruction
         pEnt.Entity().OnDestroy();
         //Mark the private data as freed, and set the managed instance to be garbage collected
         pEnt.PrivateData = null;
     }
 }
示例#4
0
        public void Use(Edict pentUsed, Edict pentOther)
        {
            var used = pentUsed.Entity();

            var other = pentOther.Entity();

            if (used != null && (used.Flags & EntFlags.KillMe) == 0)
            {
                used.Use(other, other, UseType.Toggle, 0);
            }
        }
示例#5
0
        public void Think(Edict pent)
        {
            var thinker = pent.Entity();

            if (thinker != null)
            {
                if ((thinker.Flags & EntFlags.Dormant) != 0)
                {
                    Log.Alert(AlertType.Error, $"Dormant entity {thinker.ClassName} is thinking!!");
                }

                thinker.Think();
            }
        }
示例#6
0
        public void Touch(Edict pentTouched, Edict pentOther)
        {
            if (TouchDisabled)
            {
                return;
            }

            var touched = pentTouched.Entity();

            var other = pentOther.Entity();

            if (touched != null && other != null && ((touched.Flags | other.Flags) & EntFlags.KillMe) == 0)
            {
                touched.Touch(other);
            }
        }
示例#7
0
        public void SetupVisibility(Edict pViewEntity, Edict pClient, out IntPtr pvs, out IntPtr pas)
        {
            var client = pClient.Entity();

            // Find the client's PVS
            var view = pViewEntity?.TryGetEntity() ?? client;

            if ((client.Flags & EntFlags.Proxy) != 0)
            {
                pvs = IntPtr.Zero;    // the spectator proxy sees
                pas = IntPtr.Zero;    // and hears everything
                return;
            }

            var org = view.Origin + view.ViewOffset;

            if ((view.Flags & EntFlags.Ducking) != 0)
            {
                org += (WorldConstants.HULL_MIN - WorldConstants.DUCK_HULL_MIN);
            }

            pvs = EngineServer.SetFatPVS(org);
            pas = EngineServer.SetFatPAS(org);
        }
示例#8
0
        public bool AddToFullPack(EntityState state, int e, Edict ent, Edict host, HostFlags hostFlags, bool isPlayer, IntPtr pSet)
        {
            //Never add entities that aren't in use
            if (ent.Free)
            {
                return(false);
            }

            var entity     = ent.Entity();
            var hostEntity = host.Entity();

            // don't send if flagged for NODRAW and it's not the host getting the message
            if ((entity.Effects & EntityEffects.NoDraw) != 0 &&
                (entity != hostEntity))
            {
                return(false);
            }

            // Ignore ents without valid / visible models
            if (entity.ModelIndex == 0 || string.IsNullOrEmpty(entity.ModelName))
            {
                return(false);
            }

            // Don't send spectators to other players
            if ((entity.Flags & EntFlags.Spectator) != 0 && (entity != hostEntity))
            {
                return(false);
            }

            // Ignore if not the host and not touching a PVS/PAS leaf
            // If pSet is NULL, then the test will always succeed and the entity will be added to the update
            if (entity != hostEntity)
            {
                if (!EngineServer.CheckVisibility(ent, pSet))
                {
                    return(false);
                }
            }

            // Don't send entity to local client if the client says it's predicting the entity itself.
            if ((entity.Flags & EntFlags.SkipLocalHost) != 0)
            {
                if ((hostFlags & HostFlags.SkipLocalEnts) != 0 && (entity.Owner == hostEntity))
                {
                    return(false);
                }
            }

            if (hostEntity.GroupInfo != 0)
            {
                Trace.PushGroupTrace(hostEntity.GroupInfo, GroupOp.And);

                try
                {
                    Trace.GetGroupTrace(out var currentMask, out var currentOp);

                    // Should always be set, of course
                    if (entity.GroupInfo != 0)
                    {
                        if (currentOp == GroupOp.And)
                        {
                            if ((entity.GroupInfo & hostEntity.GroupInfo) == 0)
                            {
                                return(false);
                            }
                        }
                        else if (currentOp == GroupOp.NAnd)
                        {
                            if ((entity.GroupInfo & hostEntity.GroupInfo) != 0)
                            {
                                return(false);
                            }
                        }
                    }
                }
                finally
                {
                    //There is a bug in the SDK that can cause the last group trace to remain if it failed the tests above
                    Trace.PopGroupTrace();
                }
            }

            //This is done by the wrapper since there's no memset in managed code
            //memset(state, 0, sizeof( * state) );

            // Assign index so we can track this entity from frame to frame and
            //  delta from it.
            state.Number     = e;
            state.EntityType = EntityType.Normal;

            // Flag custom entities.
            if ((entity.Flags & EntFlags.CustomEntity) != 0)
            {
                state.EntityType = EntityType.Beam;
            }

            //
            // Copy state data
            //

            // Round animtime to nearest millisecond
            state.AnimTime = (float)((int)(1000.0 * entity.AnimationTime) / 1000.0);

            state.Origin = entity.Origin;
            state.Angles = entity.Angles;
            state.Mins   = entity.Mins;
            state.Maxs   = entity.Maxs;

            state.EndPos   = entity.EndPosition;
            state.StartPos = entity.StartPosition;

            state.ImpactTime = entity.ImpactTime;
            state.StartTime  = entity.StartTime;

            state.ModelIndex = entity.ModelIndex;

            state.Frame = entity.Frame;

            state.Skin    = (short)entity.Skin;
            state.Effects = entity.Effects;

            // This non-player entity is being moved by the game .dll and not the physics simulation system
            //  make sure that we interpolate it's position on the client if it moves
            if (!isPlayer &&
                entity.AnimationTime != 0 &&
                entity.Velocity[0] == 0 &&
                entity.Velocity[1] == 0 &&
                entity.Velocity[2] == 0)
            {
                state.EFlags |= EntityStateFlags.SLerp;
            }

            state.Scale    = entity.Scale;
            state.Solid    = entity.Solid;
            state.ColorMap = entity.ColorMap;

            state.MoveType  = entity.MoveType;
            state.Sequence  = entity.Sequence;
            state.FrameRate = entity.FrameRate;
            state.Body      = entity.Body;

            for (var i = 0; i < 4; ++i)
            {
                state.SetController(i, entity.GetController(i));
            }

            for (var i = 0; i < 2; ++i)
            {
                state.SetBlending(i, entity.GetBlending(i));
            }

            state.RenderMode   = entity.RenderMode;
            state.RenderAmount = (int)entity.RenderAmount;
            state.RenderEffect = entity.RenderEffect;

            state.RenderColor = new Color24
            {
                r = (byte)entity.RenderColor.x,
                g = (byte)entity.RenderColor.y,
                b = (byte)entity.RenderColor.z
            };

            state.AimEnt = 0;
            if (entity.AimEntity != null)
            {
                state.AimEnt = entity.AimEntity.EntIndex();
            }

            state.Owner = 0;
            if (entity.Owner != null)
            {
                var owner = entity.Owner.EntIndex();

                // Only care if owned by a player
                if (owner >= 1 && owner <= Globals.MaxClients)
                {
                    state.Owner = owner;
                }
            }

            // HACK:  Somewhat...
            // Class is overridden for non-players to signify a breakable glass object ( sort of a class? )
            if (!isPlayer)
            {
                state.PlayerClass = entity.PlayerClass;
            }

            // Special stuff for players only
            if (isPlayer)
            {
                state.BaseVelocity = entity.BaseVelocity;

                state.WeaponModel  = EngineModel.IndexOf(entity.WeaponModelName);
                state.GaitSequence = entity.GaitSequence;
                state.Spectator    = (entity.Flags & EntFlags.Spectator) != 0;
                state.Friction     = entity.Friction;

                state.Gravity = entity.Gravity;
                //		state.Team			= entity.Team;
                //
                state.UseHull = (entity.Flags & EntFlags.Ducking) != 0 ? 1 : 0;
                state.Health  = (int)entity.Health;
            }

            return(true);
        }