Declaration of trigger arguement, adding trigger into dictionary
Inheritance: EventArgs
Example #1
0
        // called on player's death
        public void Death(TriggerArgs args)
        {
            BlueRnd();
            RedRnd();
            IPlayer killedPlayer = (IPlayer)args.Sender;

            if (killedPlayer.GetTeam() == PlayerTeam.Team2)
            {
                bluDeathG += GetTDamage(killedPlayer); bluKills++;
            }
            if (killedPlayer.GetTeam() == PlayerTeam.Team1)
            {
                redDeathG += GetTDamage(killedPlayer); redKills++;
            }
            if (killedPlayer.GetTeam() == PlayerTeam.Team3)
            {
                Vector2 pos = killedPlayer.GetWorldPosition();
                Game.PlaySound("MenuCancel", pos, 1);
                killedPlayer.Remove();
            }
            if ((args.Sender != null) && (args.Sender is IPlayer))
            {
                if (redFDamage < DAMAGE_LIMIT || blueFDamage < DAMAGE_LIMIT && bluTeam > 0 && redTeam > 0)
                {
                    IUser user = killedPlayer.GetUser();
                    if (user != null)
                    {
                        //store user to respawn and body to remove
                        m_deadPlayers.Add(new DeadPlayer(Game.TotalElapsedGameTime, user, killedPlayer, killedPlayer.GetTeam()));
                    }
                }
                else
                {
                    WhoWins();
                }
            }
        }
Example #2
0
 public void Trigger(TriggerArgs args)
 {
     for (int i = 0; i < args.tryTimes; i++)
     {
         try
         {
             StopTrigger();
             receiveString = "";
             DiscardInBuffer();
             WriteLine("+\r\n");
             receiveString = ReadTo("\r");
             break;
         }
         catch (Exception ex)
         {
             receiveString = UniversalFlags.errorStr + ex.Message;
         }
     }
     StopTrigger();
     if (args.sender.GetType() != typeof(DM50S))
     {
         DeviceDataReceiveCompelete?.Invoke(this, receiveString);
     }
 }
Example #3
0
 public void RespawnTick(TriggerArgs args)
 {
     if (m_deadPlayers.Count > 0)
     {
         for (int i = m_deadPlayers.Count - 1; i >= 0; i--)
         { // traverse list backwards for easy removal of elements in list
             DeadPlayer deadPlayer = m_deadPlayers[i];
             if (deadPlayer.Timestamp + USER_RESPAWN_DELAY_MS < Game.TotalElapsedGameTime)
             {
                 Game.CreateDialogue("Trying to respawn " + deadPlayer.User.Name, deadPlayer.DeadBody.GetWorldPosition());
                 // time to respawn this user
                 // remove entry from list over deadPlayers
                 m_deadPlayers.RemoveAt(i);
                 // remove old body (if any)
                 if (deadPlayer.DeadBody != null)
                 {
                     if (GIB_CORPSES)
                     {
                         deadPlayer.DeadBody.Gib();
                     }
                     else
                     {
                         (deadPlayer.DeadBody).Remove();
                     }
                 }
                 // respawn user
                 IPlayer ply = deadPlayer.User.GetPlayer();
                 if (((ply == null) || (ply.IsDead)))
                 {
                     Game.CreateDialogue("Calling SpawnUser(" + deadPlayer.User.Name + ", " + deadPlayer.Team.ToString() + ")", deadPlayer.DeadBody);
                     SpawnUser(deadPlayer.User, deadPlayer.Team);
                 }
             }
         }
     }
 }
Example #4
0
        // called on player's death
        public void Death(TriggerArgs args)
        {
            BlueRnd(args);
            RedRnd(args);
            IPlayer killedPlayer = (IPlayer)args.Sender;

            // refresh death counter on the map
            if ((args.Sender != null) && (args.Sender is IPlayer))
            {
                if (killedPlayer.GetTeam() == PlayerTeam.Team1)
                {
                    vRedKills++;
                    RefreshCounter(vRedKills, "RedT");
                }
                if (killedPlayer.GetTeam() == PlayerTeam.Team2)
                {
                    vBluKills++;
                    RefreshCounter(vBluKills, "BlueT");
                }


                if (vRedKills < DEATH_LIMIT || vBluKills < DEATH_LIMIT)
                {
                    IUser user = killedPlayer.GetUser();
                    if (user != null)
                    {
                        //store user to respawn and body to remove
                        m_deadPlayers.Add(new DeadPlayer(Game.TotalElapsedGameTime, user, killedPlayer, killedPlayer.GetTeam()));
                    }
                }
                else
                {
                    WhoWins(args);
                }
            }
        }
        public override void DoAction(IEventArgs args)
        {
            var contexts = args.GameContext;
            var player   = GetPlayerEntity(args);

            var  factory          = contexts.session.entityFactoryObject.SceneObjectEntityFactory;
            var  slot             = (EWeaponSlotType)slotIndex;
            var  lastWeaponScan   = player.WeaponController().GetWeaponAgent(slot).ComponentScan;
            bool generateSceneObj = player.WeaponController().DropWeapon(slot);

            if (!generateSceneObj || lastWeaponScan.IsUnSafeOrEmpty())
            {
                return;
            }
            var unitPos = pos.Select(args);
            SceneObjectEntity weapon;

            if (fixDrop)
            {
                weapon = factory.CreateDropSceneWeaponObjectEntity(lastWeaponScan, unitPos.Vector3, args.GetInt(lifeTime)) as SceneObjectEntity;
            }
            else
            {
                weapon = factory.CreateDropSceneWeaponObjectEntity(lastWeaponScan, player, args.GetInt(lifeTime), null) as SceneObjectEntity;
            }
            if (null != weapon)
            {
                TriggerArgs ta = new TriggerArgs();
                ta.AddPara(new IntPara("weaponId", lastWeaponScan.ConfigId));
                ta.AddPara(new FloatPara("weaponx", weapon.position.Value.x));
                ta.AddPara(new FloatPara("weapony", weapon.position.Value.y));
                ta.AddPara(new FloatPara("weaponz", weapon.position.Value.z));
                ta.AddUnit("current", (FreeData)player.freeData.FreeData);
                args.Trigger(FreeTriggerConstant.WEAPON_DROP, ta);
            }
        }
Example #6
0
        public void ExecuteUserCmd(IPlayerUserCmdGetter getter, IUserCmd cmd)
        {
            PlayerEntity myEntity = getter.OwnerEntity as PlayerEntity;

            if (null == myEntity)
            {
                return;
            }

            var myState = myEntity.stateInterface.State;

            if (myEntity.gamePlay.IsSave || myEntity.gamePlay.IsBeSave)
            {
                PlayerEntity teamEntity = _contexts.player.GetEntityWithEntityKey(myEntity.gamePlay.SavePlayerKey);
                if (null == teamEntity)
                {
                    StopSave(myEntity, true);
                    return;
                }

                if (myEntity.time.ClientTime - myEntity.gamePlay.SaveTime >= saveTime)
                {
                    if (myEntity.gamePlay.IsSave)
                    {
                        myEntity.statisticsData.Statistics.SaveCount++;
                    }
                    else
                    {
                        myEntity.statisticsData.Statistics.BeSaveCount++;
                        myEntity.gamePlay.CurHp = myEntity.gamePlay.MaxHp * 0.1f;
                        if (SharedConfig.IsServer)
                        {
                            myEntity.gamePlay.ChangeLifeState(EPlayerLifeState.Alive, myEntity.time.ClientTime);
                        }
                    }

                    try
                    {
                        var args = _contexts.session.commonSession.FreeArgs as IEventArgs;
                        if (args != null && SharedConfig.IsServer)
                        {
                            TriggerArgs ta = new TriggerArgs();
                            ta.AddUnit("savor", (FreeData)(myEntity.gamePlay.IsSave ? myEntity.freeData.FreeData : teamEntity.freeData.FreeData));
                            ta.AddUnit("saved", (FreeData)(myEntity.gamePlay.IsSave ? teamEntity.freeData.FreeData : myEntity.freeData.FreeData));
                            args.Trigger(FreeTriggerConstant.PLAYER_RESCUE_SUCCESS, ta);
                        }
                    }
                    catch (Exception e)
                    {
                        _logger.ErrorFormat("player rescue success trigger failed", e);
                    }

                    StopSave(myEntity, false);
                    return;
                }

                if (Vector3.Distance(myEntity.position.Value, teamEntity.position.Value) > SharedConfig.MaxSaveDistance)
                {
                    StopSave(myEntity, true);
                    StopSave(teamEntity, true);
                    return;
                }

                if (myEntity.gamePlay.IsSave)
                {
                    if (!cmd.IsF || myState.NeedInterruptRescue() || !myEntity.gamePlay.IsLifeState(EPlayerLifeState.Alive) ||
                        GetAngle(myEntity, teamEntity) > SharedConfig.MaxSaveAngle)
                    {
                        StopSave(myEntity, true);
                        StopSave(teamEntity, true);
                        return;
                    }
                }
                else
                {
                    if (myEntity.gamePlay.IsDead())
                    {
                        StopSave(myEntity, true);
                        StopSave(teamEntity, true);
                        return;
                    }
                }
            }

            if (cmd.IsUseAction && cmd.UseType == (int)EUseActionType.Player && myEntity.gamePlay.IsSave == false &&
                myState.GetCurrentMovementState() == MovementInConfig.Idle &&
                myState.GetCurrentPostureState() != PostureInConfig.Land && myState.GetCurrentPostureState() != PostureInConfig.Prone)
            {
                PlayerEntity saveEntity = _contexts.player.GetEntityWithEntityKey(new EntityKey(cmd.UseEntityId, (int)EEntityType.Player));
                if (saveEntity != null && SharedConfig.IsServer)
                {
                    PlayerAnimationAction.DoAnimation(_contexts, PlayerAnimationAction.Rescue, myEntity, true);
                    myEntity.gamePlay.IsSave          = true;
                    myEntity.gamePlay.SaveTime        = myEntity.time.ClientTime;
                    myEntity.gamePlay.SavePlayerKey   = saveEntity.entityKey.Value;
                    saveEntity.gamePlay.IsBeSave      = true;
                    saveEntity.gamePlay.SaveTime      = saveEntity.time.ClientTime;
                    saveEntity.gamePlay.SavePlayerKey = myEntity.entityKey.Value;

                    SimpleProto data = FreePool.Allocate();
                    data.Key = FreeMessageConstant.CountDown;
                    data.Bs.Add(true);
                    data.Fs.Add(saveTime / 1000);
                    FreeMessageSender.SendMessage(myEntity, data);
                    FreeMessageSender.SendMessage(saveEntity, data);
                }
            }
        }
Example #7
0
	public void DoSomethingAwsome (object o, TriggerArgs e){
		Debug.Log (e);
	}
Example #8
0
 public void Death(TriggerArgs args)
 {
 }
Example #9
0
 /// <summary>
 /// Starts the action like when its trigger is activated.
 /// </summary>
 /// <param name="args"></param>
 /// <exception cref="InvalidOperationException">Called in a wrong place or from a wrong thread. More info in Ramarks.</exception>
 /// <remarks>
 /// Must be called while <see cref="ActionTriggers.Run"/> is running, from the same thread that called it.
 /// </remarks>
 public void RunAction(TriggerArgs args)
 {
     triggers.ThrowIfNotRunning_();
     triggers.ThrowIfNotMainThread_();
     triggers.RunAction_(this, args);
 }
Example #10
0
 internal TOBAArgs(TriggerArgs args)
 {
     ActionArgs = args;
     Exception  = null;
 }
Example #11
0
        /// <summary>
        /// Triggers the ballons group, making them go up
        /// </summary>
        /// <remarks>
        /// Tick called by an area trigger when players are moved to the peach area
        /// </remarks>
        /// <param name="args">The tick arguments</param>
        public void BalloonsParty(TriggerArgs args)
        {
            IObjectGroupMarker groupOne = (IObjectGroupMarker)Game.GetSingleObjectByCustomID("BalloonsGroupOne");

            groupOne.Trigger();
        }
Example #12
0
        public void Run(ActionTrigger trigger, TriggerArgs args, int muteMod)
        {
            Action actionWrapper = () => {
                var opt = trigger.options;
                try {
                    _MuteMod(ref muteMod);

                    string sTrigger = null;
                    if (ATask.Role == ATRole.MiniProgram)
                    {
                        Util.Log_.Run.Write($"Trigger action started. Trigger: {sTrigger = trigger.ToString()}");
                    }

                    AOpt.Reset();

                    var baArgs = new TOBAArgs(args);                     //struct
#if true
                    opt.before?.Invoke(baArgs);
#else
                    if (opt.before != null)
                    {
                        bool called = false;
                        if (t_beforeCalled == null)
                        {
                            t_beforeCalled = new List <Action <bool> > {
                                opt.before
                            }
                        }
                        ;
                        else if (!t_beforeCalled.Contains(opt.before))
                        {
                            t_beforeCalled.Add(opt.before);
                        }
                        else
                        {
                            called = true;
                        }
                        opt.before(!called);
                    }
#endif
                    try {
                        trigger.Run(args);

                        if (sTrigger != null)
                        {
                            Util.Log_.Run.Write($"Trigger action ended. Trigger: {sTrigger}");
                        }
                    }
                    catch (Exception e1) {
                        if (sTrigger != null)
                        {
                            Util.Log_.Run.Write($"Unhandled exception in trigger action. Trigger: {sTrigger}. Exception: {e1.ToStringWithoutStack()}");
                        }

                        baArgs.Exception = e1;
                        AOutput.Write(e1);
                    }
                    opt.after?.Invoke(baArgs);
                }
                catch (Exception e2) {
                    AOutput.Write(e2);
                }
                finally {
                    if (opt.thread < -1 && opt.ifRunning == 0)
                    {
                        _d.TryRemove(trigger, out _);
                    }
                }
            };
            //never mind: we should not create actionWrapper if cannot run. But such cases are rare. Fast and small, about 64 bytes.

            int threadId = trigger.options.thread;

            if (threadId >= 0)              //dedicated thread
            {
                _Thread h = null; foreach (var v in _a)
                {
                    if (v.id == threadId)
                    {
                        h = v; break;
                    }
                }
                if (h == null)
                {
                    _a.Add(h = new _Thread(threadId));
                }
                if (h.RunAction(actionWrapper, trigger))
                {
                    return;
                }
            }
            else if (threadId == -1)                //main thread
            {
                actionWrapper();
                return;
                //note: can reenter. Probably it is better than to cancel if already running.
            }
            else
            {
                bool canRun         = true;
                bool singleInstance = trigger.options.ifRunning == 0;
                if (singleInstance)
                {
                    _d ??= new System.Collections.Concurrent.ConcurrentDictionary <ActionTrigger, object>();
                    if (_d.TryGetValue(trigger, out var tt))
                    {
                        switch (tt)
                        {
                        case Thread thread:
                            if (thread.IsAlive)
                            {
                                canRun = false;
                            }
                            break;

                        case Task task:
                            //AOutput.Write(task.Status);
                            switch (task.Status)
                            {
                            case TaskStatus.RanToCompletion:
                            case TaskStatus.Faulted:
                            case TaskStatus.Canceled: break;

                            default: canRun = false; break;
                            }
                            break;
                        }
                    }
                }

                if (canRun)
                {
                    if (threadId == -2)                      //new thread
                    {
                        var thread = new Thread(actionWrapper.Invoke)
                        {
                            IsBackground = true
                        };
                        thread.SetApartmentState(ApartmentState.STA);
                        if (singleInstance)
                        {
                            _d[trigger] = thread;
                        }
                        try { thread.Start(); }
                        catch (OutOfMemoryException) {                        //too many threads, probably 32-bit process
                            if (singleInstance)
                            {
                                _d.TryRemove(trigger, out _);
                            }
                            _OutOfMemory();
                            //SHOULDDO: before starting thread, warn if there are too many action threads.
                            //	In 32-bit process normally fails at ~3000 threads.
                            //	Unlikely to fail in 64-bit process, but at ~15000 threads starts to hang temporarily, which causes hook timeout, slow mouse, other anomalies.
                        }
                    }
                    else                         //thread pool
                    {
                        var task = new Task(actionWrapper);
                        if (singleInstance)
                        {
                            _d[trigger] = task;
                        }
                        task.Start();
                    }
                    return;
                }
            }

            if (muteMod != 0)
            {
                ThreadPool.QueueUserWorkItem(_ => _MuteMod(ref muteMod));
            }
        }
Example #13
0
        public void PunchStronker(TriggerArgs args)
        {
            foreach (IUser user in Game.GetActiveUsers())
            {
                if (user.GetPlayer() != null)
                {
                    IPlayer ply = user.GetPlayer();

                    if (!(user.GetPlayer()).IsDead)
                    {
                        if (PunchBook.ContainsKey(ply))
                        {
                            if (ply.IsMeleeAttacking || ply.IsJumpAttacking)
                            {
                                float time = PunchBook[ply];
                                if (time + 510f <= Game.TotalElapsedGameTime)
                                {
                                    PunchBook[ply] = Game.TotalElapsedGameTime;
                                    Area area = puncharea;
                                    area.Move(new Vector2(ply.FacingDirection * 4, 0) + ply.GetWorldPosition());
                                    foreach (IObject obj in Game.GetObjectsByArea(area))
                                    {
                                        if (obj.Name != "SupplyCrate00" && !(obj is IObjectWeaponItem) && !(obj is IPlayer) && !obj.Name.StartsWith("Bg") && !NoMeleeObject.Contains(obj) && (obj.GetBodyType() == BodyType.Dynamic || AffectStaticles))
                                        {
                                            float mass = Math.Max(obj.GetMass(), 0.001f) * 50;
                                            obj.SetLinearVelocity(obj.GetLinearVelocity() + new Vector2(ply.FacingDirection, 0) * (AddedPunchForce / mass));
                                            obj.SetAngularVelocity(obj.GetAngularVelocity() - AddedPunchForce / mass * Math.Sign(ply.GetWorldPosition().X - obj.GetWorldPosition().X));
                                            Game.PlayEffect("H_T", new Vector2(ply.FacingDirection * 6, 0) + ply.GetWorldPosition());

                                            if (obj.Name.StartsWith("Wood") || obj.Name.StartsWith("Crate"))
                                            {
                                                Game.PlayEffect("W_P", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            if (obj.Name.Contains("Paper"))
                                            {
                                                Game.PlayEffect("PPR_D", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            if (obj.Name.Contains("Glass"))
                                            {
                                                Game.PlayEffect("G_P", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            if (MeleeDamageObjects.Contains(obj.Name) || DestroyEveryThing)
                                            {
                                                obj.SetHealth(obj.GetHealth() - AddedPunchDamage);
                                            }
                                            if (obj.GetBodyType() == BodyType.Dynamic && (obj.GetWorldPosition().X < ply.GetWorldPosition().X - 8 || obj.GetWorldPosition().X > ply.GetWorldPosition().X + 8))
                                            {
                                                obj.TrackAsMissile(true);
                                            }
                                        }
                                        if (obj is IPlayer)
                                        {
                                            IPlayer plye = (IPlayer)obj;
                                            if ((plye.GetTeam() != ply.GetTeam() || ply.GetTeam() == PlayerTeam.Independent) && ply != plye)
                                            {
                                                if (plye.IsStaggering || plye.IsFalling || plye.IsDead)
                                                {
                                                    plye.SetLinearVelocity(plye.GetLinearVelocity() + new Vector2(ply.FacingDirection, 0) * (AddedPunchForce));
                                                }
                                                plye.SetHealth(plye.GetHealth() - AddedPunchDamage_Players);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (!PunchBook.ContainsKey(ply))
                        {
                            PunchBook.Add(ply, Game.TotalElapsedGameTime);
                        }
                    }
                }
            }
        }
Example #14
0
        public void MovetoBase(TriggerArgs args)
        {
            IPlayer sender = (IPlayer)args.Sender;

            if ((sender != null) && (sender is IPlayer) && (!sender.IsDiving))
            {
                IObject Where  = (IObject)args.Caller;
                IPlayer player = (IPlayer)args.Sender;
                IUser   user   = player.GetUser();

                switch (Where.CustomId)
                {
                case "RedBase":
                    if (bluTeam >= redTeam)
                    {
                        player.SetTeam(PlayerTeam.Team2);
                        redTeam++;
                        if (player.IsBot)
                        {
                            break;
                        }
                        GetAway("Red", player);
                    }
                    else
                    {
                        Game.ShowPopupMessage("Choose another team");
                    }
                    break;

                case "BlueBase":
                    if (redTeam >= bluTeam)
                    {
                        player.SetTeam(PlayerTeam.Team1);
                        bluTeam++;
                        if (player.IsBot)
                        {
                            break;
                        }
                        GetAway("Blue", player);
                    }
                    else
                    {
                        Game.ShowPopupMessage("Choose another team");
                    }

                    break;

                default:
                    Game.ShowPopupMessage("Something is wrong, Check the MovetoBase void");
                    break;
                }

                if (!player.IsBot || player.GetTeam() == PlayerTeam.Team3)
                {
                    return;
                }
                rnd = new Random();
                var i = rnd.Next(0, _Classes.Length - 1);

                var o = Game.GetFirstObject(_Classes[i]) as IObjectActivateTrigger;
                if (o == null)
                {
                    return;
                }
                ClassChooser(new TriggerArgs(o, player, false));
            }
        }
Example #15
0
 protected override void Handler(object sender, TriggerArgs args)
 {
     _handler(sender, args);
 }
Example #16
0
        public virtual void Drop(PlayerEntity player, EWeaponSlotType slot, IUserCmd cmd)
        {
            if (slot == EWeaponSlotType.ThrowingWeapon)
            {
                DoDropGrenade(player, slot, cmd);
                return;
            }
            var heldAgent = player.WeaponController().HeldWeaponAgent;

            if (heldAgent.IsValid())
            {
                var  dropPos          = player.GetHandWeaponPosition();
                var  playerTrans      = player.characterContoller.Value.transform;
                var  forward          = playerTrans.forward;
                var  pos              = dropPos + forward * runtimeGameConfig.WeaponDropOffset;
                var  weaponScacn      = heldAgent.ComponentScan;
                bool generateSceneObj = player.WeaponController().DropWeapon(slot);
                if (!generateSceneObj || weaponScacn.IsUnSafeOrEmpty())
                {
                    return;
                }
                //     DebugUtil.LogInUnity(weaponScacn.ToString(), DebugUtil.DebugColor.Black);
                RaycastHit        hhit;
                SceneObjectEntity sceneObjectEntity;
                if (Physics.Raycast(dropPos, forward, out hhit, runtimeGameConfig.WeaponDropOffset,
                                    UnityLayers.SceneCollidableLayerMask))
                {
                    RaycastHit vhit;
                    if (Physics.Raycast(hhit.point, Vector3.down, out vhit, 100, UnityLayers.SceneCollidableLayerMask))
                    {
                        sceneObjectEntity =
                            sceneObjectEntityFactory.CreateDropSceneWeaponObjectEntity(weaponScacn, vhit.point,
                                                                                       sceneWeaponLifeTime) as SceneObjectEntity;
                    }
                    else
                    {
                        sceneObjectEntity =
                            sceneObjectEntityFactory.CreateDropSceneWeaponObjectEntity(weaponScacn,
                                                                                       playerTrans.position, sceneWeaponLifeTime) as SceneObjectEntity;
                    }
                }
                else
                {
                    RaycastHit vhit;
                    if (Physics.Raycast(pos, Vector3.down, out vhit, 100, UnityLayers.SceneCollidableLayerMask))
                    {
                        sceneObjectEntity =
                            sceneObjectEntityFactory.CreateDropSceneWeaponObjectEntity(weaponScacn, vhit.point,
                                                                                       sceneWeaponLifeTime) as SceneObjectEntity;
                    }
                    else
                    {
                        sceneObjectEntity =
                            sceneObjectEntityFactory.CreateDropSceneWeaponObjectEntity(weaponScacn,
                                                                                       playerTrans.position, sceneWeaponLifeTime) as SceneObjectEntity;
                    }
                }

                IEventArgs args = commonSession.FreeArgs as IEventArgs;
                if (null != args && null != sceneObjectEntity)
                {
                    TriggerArgs ta = new TriggerArgs();
                    ta.AddPara(new IntPara("weaponId", weaponScacn.ConfigId));
                    ta.AddPara(new FloatPara("weaponx", sceneObjectEntity.position.Value.x));
                    ta.AddPara(new FloatPara("weapony", sceneObjectEntity.position.Value.y));
                    ta.AddPara(new FloatPara("weaponz", sceneObjectEntity.position.Value.z));
                    ta.AddUnit("current", (FreeData)player.freeData.FreeData);
                    args.Trigger(FreeTriggerConstant.WEAPON_DROP, ta);
                }
            }
        }
Example #17
0
 public void DespawnTimer(TriggerArgs args)
 {
     ToDespawn[0].SetEnabled(true);
     ToDespawn.Remove(ToDespawn[0]);
     ((IObject)args.Caller).Remove();
 }
Example #18
0
        public void Buy_Weapon(TriggerArgs args)
        {
            IPlayer    sender      = (IPlayer)args.Sender;
            IObject    caller      = (IObject)args.Caller;
            int        ind         = GetPlayerDataIndex(sender);
            WeaponItem wpn         = WeaponItem.NONE;
            short      weaponIndex = 0;

            switch (caller.CustomId)
            {
            case "BAT":
                wpn         = WeaponItem.BAT;
                weaponIndex = 1;
                break;

            case "MACHETE":
                wpn         = WeaponItem.MACHETE;
                weaponIndex = 1;
                break;

            case "AXE":
                wpn         = WeaponItem.AXE;
                weaponIndex = 1;
                break;

            case "HAMMER":
                wpn         = WeaponItem.HAMMER;
                weaponIndex = 1;
                break;

            case "KATANA":
                wpn         = WeaponItem.KATANA;
                weaponIndex = 1;
                break;

            case "PISTOL":
                wpn         = WeaponItem.PISTOL;
                weaponIndex = 2;
                break;

            case "REVOLVER":
                wpn         = WeaponItem.REVOLVER;
                weaponIndex = 2;
                break;

            case "FLAREGUN":
                wpn         = WeaponItem.FLAREGUN;
                weaponIndex = 2;
                break;

            case "MAGNUM":
                wpn         = WeaponItem.MAGNUM;
                weaponIndex = 2;
                break;

            case "UZI":
                wpn         = WeaponItem.UZI;
                weaponIndex = 2;
                break;

            case "GRENADES":
                wpn         = WeaponItem.GRENADES;
                weaponIndex = 4;
                break;

            case "SLOWMO_5":
                if (Prices[WeaponItem.SLOWMO_5] <= Players[ind].Points && !Players[ind].Weapons.ContainsKey(5))
                {
                    wpn = WeaponItem.SLOWMO_5;
                }
                else if (Prices[WeaponItem.SLOWMO_10] <= Players[ind].Points)
                {
                    wpn = WeaponItem.SLOWMO_10;
                }
                weaponIndex = 5;
                break;

            case "LAZER":
                wpn         = WeaponItem.LAZER;
                weaponIndex = 6;
                break;

            case "PIPE":
                wpn         = WeaponItem.PIPE;
                weaponIndex = 1;
                break;

            case "MOLOTOVS":
                wpn         = WeaponItem.MOLOTOVS;
                weaponIndex = 4;
                break;

            case "SHOTGUN":
                wpn         = WeaponItem.SHOTGUN;
                weaponIndex = 3;
                break;

            case "ASSAULT":
                wpn         = WeaponItem.ASSAULT;
                weaponIndex = 3;
                break;

            case "TOMMYGUN":
                wpn         = WeaponItem.SMG;
                weaponIndex = 3;
                break;

            case "SNIPER":
                wpn         = WeaponItem.SNIPER;
                weaponIndex = 3;
                break;

            case "SAWED_OFF":
                wpn         = WeaponItem.SAWED_OFF;
                weaponIndex = 3;
                break;
            }

            if (wpn != WeaponItem.NONE)
            {
                if (Players[ind].Weapons.ContainsKey(weaponIndex))
                {
                    if ((Prices[Players[ind].Weapons[weaponIndex]] - Prices[wpn]) + Players[ind].Points >= 0)
                    {
                        Players[ind].Points += Prices[Players[ind].Weapons[weaponIndex]] - Prices[wpn];
                        Game.PlayEffect("PWT", sender.GetWorldPosition(), (Prices[Players[ind].Weapons[weaponIndex]] - Prices[wpn]).ToString());
                        Players[ind].Weapons[weaponIndex] = wpn;
                        sender.GiveWeaponItem(wpn);
                    }
                    else
                    {
                        Game.PlayEffect("PWT", sender.GetWorldPosition(), "not enough points\n" + Players[ind].Points.ToString() + " spare points");
                    }
                }
                else if (Prices[wpn] <= Players[ind].Points)
                {
                    Players[ind].Points -= Prices[wpn];
                    Players[ind].Weapons.Add(weaponIndex, wpn);
                    sender.GiveWeaponItem(wpn);
                }
                else
                {
                    Game.PlayEffect("PWT", sender.GetWorldPosition(), "not enough points\n" + Players[ind].Points.ToString() + " spare points");
                }
            }
            else
            {
                Game.PlayEffect("PWT", sender.GetWorldPosition(), "not enough points\n" + Players[ind].Points.ToString() + " spare points");
            }

            if (Game.TotalElapsedGameTime - Players[ind].ButtonTimeStamp < 800)
            {
                Players[ind].ButtonPressesFaults++;
            }
            if (Players[ind].ButtonPressesFaults >= 8)
            {
                Game.RunCommand(string.Format("/MSG Server: {0} STOP SPAMMING IT!!", sender.Name));
                Second_Room(new TriggerArgs((IObjectTrigger)Game.GetSingleObjectByCustomId("Fight"), Players[ind].Player, true));
                Players[ind].ButtonPressesFaults = 0;
            }
            Players[ind].ButtonTimeStamp = Game.TotalElapsedGameTime;
        }
Example #19
0
 internal override void Run(TriggerArgs args) => RunT(args as AutotextTriggerArgs);
Example #20
0
 internal override void Run(TriggerArgs args) => RunT(args as HotkeyTriggerArgs);
Example #21
0
        public void KickStronker(TriggerArgs args)
        {
            foreach (IUser user in Game.GetActiveUsers())
            {
                if (user.GetPlayer() != null)
                {
                    IPlayer ply = user.GetPlayer();

                    if (!(user.GetPlayer()).IsDead)
                    {
                        if (!KickBook.ContainsKey(ply))
                        {
                            KickBook.Add(ply, Game.TotalElapsedGameTime);
                        }
                        if (!KickPlyBook.ContainsKey(ply))
                        {
                            KickPlyBook.Add(ply, Game.TotalElapsedGameTime);
                        }
                        if (KickBook.ContainsKey(ply))
                        {
                            if (ply.IsKicking || ply.IsJumpKicking)
                            {
                                float time = KickBook[ply];
                                if (time + 375f <= Game.TotalElapsedGameTime)
                                {
                                    int i = 1;
                                    if (PrevilagePlayers.Contains(user.Name.ToLower()))
                                    {
                                        i = 3;
                                    }
                                    KickBook[ply] = Game.TotalElapsedGameTime;

                                    Area area = kickarea;
                                    area.Move(new Vector2(ply.FacingDirection * 4, 0) + ply.GetWorldPosition());

                                    foreach (IObject obj in Game.GetObjectsByArea(area))
                                    {
                                        if (obj.Name != "SupplyCrate00" && !(obj is IObjectWeaponItem) && !(obj is IPlayer) && !obj.Name.StartsWith("Bg") && !NoMeleeObject.Contains(obj) && (obj.GetBodyType() == BodyType.Dynamic || AffectStaticles))
                                        {
                                            float mass = Math.Max(obj.GetMass(), 0.001f) * 50;
                                            obj.SetLinearVelocity(obj.GetLinearVelocity() + new Vector2(ply.FacingDirection, 1) * (i * AddedKickForce / mass));
                                            obj.SetAngularVelocity(obj.GetAngularVelocity() - AddedKickForce / mass * ply.FacingDirection);

                                            if (obj.Name.StartsWith("Wood") || obj.Name.StartsWith("Crate"))
                                            {
                                                Game.PlayEffect("W_P", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            if (obj.Name.Contains("Paper"))
                                            {
                                                Game.PlayEffect("PPR_D", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            if (obj.Name.Contains("Glass"))
                                            {
                                                Game.PlayEffect("G_P", new Vector2(ply.FacingDirection * 6, -4) + ply.GetWorldPosition());
                                            }
                                            bool damag = MeleeDamageObjects.Contains(obj.Name);
                                            if (damag || DestroyEveryThing)
                                            {
                                                float div = 1f;
                                                if (DestroyEveryThing && !damag)
                                                {
                                                    div = 20f;
                                                }
                                                obj.SetHealth(obj.GetHealth() - i * AddedKickDamage / div);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (KickPlyBook.ContainsKey(ply))
                        {
                            if (ply.IsKicking || ply.IsJumpKicking)
                            {
                                float time = KickPlyBook[ply];

                                if (time + 300f <= Game.TotalElapsedGameTime)
                                {
                                    Area area = kickarea;
                                    area.Move(new Vector2(ply.FacingDirection * 4, 0) + ply.GetWorldPosition());
                                    int j = 0;
                                    foreach (IObject obj in Game.GetObjectsByArea(area))
                                    {
                                        if (obj is IPlayer && obj != ply)
                                        {
                                            IPlayer plye = (IPlayer)obj;
                                            if ((plye.GetTeam() != ply.GetTeam() || ply.GetTeam() == PlayerTeam.Independent) && (plye.IsStaggering || plye.IsFalling || plye.IsDead))
                                            {
                                                plye.SetHealth(plye.GetHealth() - AddedKickDamage_Players);
                                                plye.SetLinearVelocity(plye.GetLinearVelocity() + new Vector2(ply.FacingDirection, 1) * (AddedKickForce_Players));
                                                j = 1;
                                            }
                                        }
                                    }
                                    if (j == 1)
                                    {
                                        KickPlyBook[ply] = Game.TotalElapsedGameTime;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #22
0
 public void JetPack(TriggerArgs args)
 {
     foreach (IPlayer ply in Game.GetPlayers())
     {
         IObjectPullJoint         pullit   = null;
         IObjectTargetObjectJoint targetit = null;
         float forc = 0;
         if (!Bbook.ContainsKey(ply) && !ply.IsDead)
         {
             ;
             Bbook.Add(ply, true);
             IObjectWeldJoint       weld = (IObjectWeldJoint)Game.CreateObject("WeldJoint", ply.GetWorldPosition());
             IObjectActivateTrigger trig = (IObjectActivateTrigger)Game.CreateObject("ActivateTrigger", ply.GetWorldPosition() + new Vector2(0, 8));
             trig.SetBodyType(BodyType.Dynamic);
             trig.SetScriptMethod("Toggle");
             weld.AddTargetObject(trig);
             weld.AddTargetObject(ply);
         }
         if (!Gbook.ContainsKey(ply) && !ply.IsDead)
         {
             ;
             Gbook.Add(ply, 2);
         }
         if (Gbook.ContainsKey(ply) && !ply.IsDead)
         {
             int c = Gbook[ply] % demforce.Length;
             forc = force * demforce[c] / 100;
             if (ply.IsBlocking && ply.IsWalking)
             {
                 Gbook[ply] = (c + 1) % demforce.Length;
                 Game.PlayEffect("CFTXT", ply.GetWorldPosition() + new Vector2(0, 8), demforce[Gbook[ply]].ToString() + " %");
             }
         }
         if (book.ContainsKey(ply))
         {
             pullit   = book[ply];
             targetit = pullit.GetTargetObjectJoint();
             book[ply].SetWorldPosition(targetit.GetWorldPosition() + new Vector2(0, 500));
         }
         bool jeton     = (ply.IsWalking && !ply.IsDead && !ply.IsStaggering && !ply.IsRolling && (!ply.IsBlocking || ply.IsInMidAir) && !ply.IsManualAiming);
         bool mapborder = WorkOutsideBorders || Game.GetCameraArea().Contains(ply.GetWorldPosition());
         if (jeton)
         {
             if (book.ContainsKey(ply))
             {
                 book[ply].Destroy();
                 book.Remove(ply);
             }
             pullit = (IObjectPullJoint)Game.CreateObject("PullJoint", ply.GetWorldPosition() + new Vector2(0, 500));
             book.Add(ply, pullit);
             if (!mapborder)
             {
                 forc = (float)(forc / 2);
             }
             pullit.SetForce(forc);
             targetit = (IObjectTargetObjectJoint)Game.CreateObject("TargetObjectJoint", ply.GetWorldPosition());
             targetit.SetTargetObject(ply);
             pullit.SetTargetObject(concrete);
             pullit.SetTargetObjectJoint(targetit);
         }
         if (!jeton)
         {
             if (pullit != null)
             {
                 //	pullit .SetWorldPosition(ply.GetWorldPosition() + new Vector2(0,50));
                 pullit.SetForce(0f);
             }
         }
     }
 }
Example #23
0
 /// <summary>
 /// Tick called to clear the game popup message
 /// </summary>
 /// <param name="args"></param>
 public void ClearPopup(TriggerArgs args)
 {
     Game.HidePopupMessage();
 }
Example #24
0
        public void ClassChooser(TriggerArgs args)
        {
            IPlayer sender = (IPlayer)args.Sender;

            if ((sender != null) && (sender is IPlayer) && (!sender.IsDiving))
            {
                IObject Clas = (IObject)args.Caller;
                switch (Clas.CustomId)
                {
                case "i":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.CARBINE);
                    sender.GiveWeaponItem(WeaponItem.GRENADES);
                    sender.GiveWeaponItem(WeaponItem.BAT);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;



                case "a":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.ASSAULT);
                    sender.GiveWeaponItem(WeaponItem.UZI);
                    sender.GiveWeaponItem(WeaponItem.ASSAULT);
                    sender.GiveWeaponItem(WeaponItem.UZI);
                    sender.GiveWeaponItem(WeaponItem.ASSAULT);
                    sender.GiveWeaponItem(WeaponItem.UZI);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                case "s":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.MACHETE);
                    sender.GiveWeaponItem(WeaponItem.MAGNUM);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    sender.GiveWeaponItem(WeaponItem.MACHETE);
                    sender.GiveWeaponItem(WeaponItem.MAGNUM);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                case "d":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.KATANA);
                    sender.GiveWeaponItem(WeaponItem.SAWED_OFF);
                    sender.GiveWeaponItem(WeaponItem.SAWED_OFF);
                    sender.GiveWeaponItem(WeaponItem.REVOLVER);
                    sender.GiveWeaponItem(WeaponItem.REVOLVER);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                case "f":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.SNIPER);
                    sender.GiveWeaponItem(WeaponItem.PISTOL);
                    sender.GiveWeaponItem(WeaponItem.PISTOL);
                    sender.GiveWeaponItem(WeaponItem.SNIPER);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                case "g":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.PIPE);
                    sender.GiveWeaponItem(WeaponItem.SHOTGUN);
                    sender.GiveWeaponItem(WeaponItem.REVOLVER);
                    sender.GiveWeaponItem(WeaponItem.REVOLVER);
                    sender.GiveWeaponItem(WeaponItem.SHOTGUN);
                    sender.GiveWeaponItem(WeaponItem.GRENADES);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_10);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                case "h":
                    sender = (IPlayer)args.Sender;
                    RemoveWeapons(sender);
                    sender.GiveWeaponItem(WeaponItem.AXE);
                    sender.GiveWeaponItem(WeaponItem.SUB_MACHINEGUN);
                    sender.GiveWeaponItem(WeaponItem.SUB_MACHINEGUN);
                    sender.GiveWeaponItem(WeaponItem.SUB_MACHINEGUN);
                    sender.GiveWeaponItem(WeaponItem.PISTOL);
                    sender.GiveWeaponItem(WeaponItem.PISTOL);
                    sender.GiveWeaponItem(WeaponItem.SLOWMO_5);
                    if (sender.GetTeam() == PlayerTeam.Team1)
                    {
                        GetAway(VBlueRnd, sender);
                    }
                    else
                    {
                        GetAway(VRedRnd, sender);
                    }

                    break;


                default:
                    Game.ShowPopupMessage("Something is wrong, Check the ClassChooser void");
                    break;
                }
            }
        }
Example #25
0
 public void Trigger(int eventId, TriggerArgs args)
 {
     args.Trigger(this, _triggers, eventId);
 }
Example #26
0
        public void TimeVerdin(TriggerArgs args)
        {
            IPlayer tiozinho = (IPlayer)args.Sender;

            tiozinho.SetTeam(PlayerTeam.Team3);
        }
Example #27
0
        public void Run(ActionTrigger trigger, TriggerArgs args, int muteMod)
        {
            //perf.first();
            Action actionWrapper = () => {
                var o = trigger.options;

                var oldOpt = o.thread == TOThread.New ? default : opt.scope.all(inherit: false);
                             try {
                                 _MuteMod(ref muteMod);

                                 string sTrigger = null; long startTime = 0;
                                 //perf.next();
                                 if (script.role == SRole.MiniProgram)
                                 {
                                     sTrigger = trigger.ToString();
                                     Api.QueryPerformanceCounter(out startTime);
                                     print.TaskEvent_("AS " + sTrigger, startTime, trigger.sourceFile, trigger.sourceLine);
                                     //perf.next();
                                 }

                                 var baArgs = new TOBAArgs(args);        //struct
#if true
                                 o.before?.Invoke(baArgs);
#else
                                 if (o.before != null)
                                 {
                                     bool called = false;
                                     if (t_beforeCalled == null)
                                     {
                                         t_beforeCalled = new List <Action <bool> > {
                                             o.before
                                         }
                                     }
                                     ;
                                     else if (!t_beforeCalled.Contains(o.before))
                                     {
                                         t_beforeCalled.Add(o.before);
                                     }
                                     else
                                     {
                                         called = true;
                                     }
                                     o.before(!called);
                                 }
#endif
                                 try {
                                     //perf.nw();
                                     trigger.Run(args);

                                     if (sTrigger != null)
                                     {
                                         print.TaskEvent_("AE", startTime, trigger.sourceFile, trigger.sourceLine);
                                     }
                                 }
                                 catch (Exception e1) {
                                     if (sTrigger != null)
                                     {
                                         print.TaskEvent_("AF", startTime, trigger.sourceFile, trigger.sourceLine);
                                     }

                                     baArgs.Exception = e1;
                                     print.it(e1);
                                 }
                                 o.after?.Invoke(baArgs);
                             }
                             catch (Exception e2) {
                                 print.it(e2);
                             }
                             finally {
                                 oldOpt.Dispose();
                                 if (o.flags.Has(TOFlags.Single))
                                 {
                                     _d.TryRemove(trigger, out _);
                                 }
                                 if (o.thread != TOThread.Main)
                                 {
                                     toolbar.TriggerActionEndedInNonmainThread_();
                                 }
                             }
            };
            //never mind: we should not create actionWrapper if cannot run. But such cases are rare. Fast and small, about 64 bytes.

            var opt1     = trigger.options;
            int threadId = opt1.thread;

            if (threadId >= 0)               //dedicated thread
            {
                _Thread h = null; foreach (var v in _a)
                {
                    if (v.id == threadId)
                    {
                        h = v; break;
                    }
                }
                if (h == null)
                {
                    _a.Add(h = new _Thread(threadId));
                }
                if (h.RunAction(actionWrapper, trigger))
                {
                    return;
                }
            }
            else if (threadId == TOThread.Main)
            {
                actionWrapper();
                return;
                //note: can reenter. Probably it is better than to cancel if already running.
            }
            else
            {
                bool canRun = true;
                bool single = opt1.flags.Has(TOFlags.Single);
                if (single)
                {
                    _d ??= new();
                    if (_d.TryGetValue(trigger, out var tt))
                    {
                        switch (tt)
                        {
                        case Thread thread:
                            if (thread.IsAlive)
                            {
                                canRun = false;
                            }
                            break;

                        case Task task:
                            //print.it(task.Status);
                            switch (task.Status)
                            {
                            case TaskStatus.RanToCompletion:
                            case TaskStatus.Faulted:
                            case TaskStatus.Canceled: break;

                            default: canRun = false; break;
                            }
                            break;
                        }
                    }
                }

                if (canRun)
                {
                    if (threadId == TOThread.New)
                    {
                        var thread = new Thread(actionWrapper.Invoke)
                        {
                            IsBackground = true
                        };
                        //if (!opt1.flags.Has(TOFlags.MtaThread))
                        thread.SetApartmentState(ApartmentState.STA);
                        if (single)
                        {
                            _d[trigger] = thread;
                        }
                        try { thread.Start(); }
                        catch (OutOfMemoryException) {                         //too many threads, probably 32-bit process
                            if (single)
                            {
                                _d.TryRemove(trigger, out _);
                            }
                            _OutOfMemory();
                            //SHOULDDO: before starting thread, warn if there are too many action threads.
                            //	In 32-bit process normally fails at ~3000 threads.
                            //	Unlikely to fail in 64-bit process, but at ~15000 threads starts to hang temporarily, which causes hook timeout, slow mouse, other anomalies.
                        }
                    }
                    else                         //thread pool
                    {
                        var task = new Task(actionWrapper);
                        if (single)
                        {
                            _d[trigger] = task;
                        }
                        task.Start();
                    }
                    return;
                }
            }

            if (muteMod != 0)
            {
                ThreadPool.QueueUserWorkItem(_ => _MuteMod(ref muteMod));
            }
        }
Example #28
0
        //--//


        public void CheckEnter(TriggerArgs args)
        {
            if ((args.Sender != null) && (args.Sender is IPlayer))
            {
            }
        }
Example #29
0
 /// <summary>
 /// Called through <see cref="TriggerActionThreads.Run"/> in action thread.
 /// Possibly runs later.
 /// </summary>
 internal abstract void Run(TriggerArgs args);
Example #30
0
 internal override void Run(TriggerArgs args) => RunT(args as MouseTriggerArgs);
Example #31
0
 internal override void Run(TriggerArgs args) => RunT(args as WindowTriggerArgs);
Example #32
0
	public void FlyAway(object o , TriggerArgs e){
		Debug.Log("Lets Fly!!");
	}