Example #1
0
        public override void OnPlayerDamage(Entity player, Entity inflictor, Entity attacker, int damage, int dFlags, string mod, string weapon, Vector3 point, Vector3 dir, string hitLoc)
        {
            if (attacker == null || !attacker.IsPlayer || attacker.GetTeam() == player.GetTeam())
            {
                return;
            }

            if (attacker.GetTeam() == "allies")
            {
                if (weapon == "nuke_mp")
                {
                    return;
                }
                if (attacker.GetField <int>("perk_phd") == 1 && mod == "MOD_MELEE")
                {
                    attacker.Health = 1000;
                    AfterDelay(100, () =>
                    {
                        attacker.Notify("radius_exploed", attacker.Origin);
                    });
                    AfterDelay(200, () =>
                    {
                        attacker.SetMaxHealth();
                    });
                }
                if (attacker.GetField <int>("perk_doubletap") == 1 && mod.Contains("BULLET"))
                {
                    player.Call("finishplayerdamage", inflictor, attacker, new Parameter(Convert.ToInt32(damage * 0.5)), dFlags, mod, weapon, point, dir, hitLoc);
                }
                if (attacker.GetField <int>("perk_widow") == 1 && mod.Contains("BULLET"))
                {
                    attacker.SetField("perk_widow", 2);
                    WidowsWineThink(attacker, player.Origin);
                }
                if (attacker.GetField <int>("perk_widow") == 1 && (mod == "MOD_MELEE" || mod == "MOD_EXPLOSIVE" || mod == "MOD_PROJECTILE_SPLASH" || mod == "MOD_GRENADE_SPLASH"))
                {
                    if (player.GetField <float>("speed") >= 1f)
                    {
                        player.SetSpeed(0.5f);
                        player.AfterDelay(5000, e => player.SetSpeed(1));
                    }
                }
            }
            else if (attacker.GetTeam() == "axis")
            {
                if (player.GetField <int>("perk_phd") == 1 && (mod == "MOD_EXPLOSIVE" || mod == "MOD_PROJECTILE_SPLASH" || mod == "MOD_GRENADE_SPLASH"))
                {
                    player.Health = 1000;
                    AfterDelay(200, () => player.SetMaxHealth());
                }
                if (player.GetField <int>("perk_cherry") == 1 && mod == "MOD_MELEE")
                {
                    player.SetField("perk_cherry", 2);
                    player.Health = 1000;
                    AfterDelay(200, () => player.SetMaxHealth());
                    ElectricCherryThink(player);
                }
            }
        }
Example #2
0
        public override void OnPlayerDamage(Entity player, Entity inflictor, Entity attacker, int damage, int dFlags, string mod, string weapon, Vector3 point, Vector3 dir, string hitLoc)
        {
            if (attacker == null || !attacker.IsPlayer || attacker.GetTeam() == player.GetTeam())
            {
                return;
            }

            if (attacker.GetTeam() == "allies")
            {
                if (Call <int>("getdvarint", "bonus_double_points") == 1)
                {
                    if (player.GetField <int>("rtd_flag") == 1 || player.GetField <int>("rtd_king") == 1)
                    {
                        attacker.WinCash(40);
                    }
                    else
                    {
                        attacker.WinCash(20);
                    }
                }
                else
                {
                    if (player.GetField <int>("rtd_flag") == 1 || player.GetField <int>("rtd_king") == 1)
                    {
                        attacker.WinCash(20);
                    }
                    else
                    {
                        attacker.WinCash(10);
                    }
                }

                if (Call <int>("getdvarint", "bonus_insta_kill") == 1)
                {
                    player.Health = 3;
                    return;
                }
                else
                {
                    if (weapon.Contains("iw5_msr") || weapon.Contains("iw5_l96a1") || weapon.Contains("iw5_as50"))
                    {
                        player.Health = 3;
                        return;
                    }
                }

                if (Utility.GetDvar <int>("bonus_killing_time") == 1)
                {
                    if (player.GetField <float>("speed") >= 1f)
                    {
                        player.SetSpeed(0.5f);
                        player.AfterDelay(5000, e => player.SetSpeed(1));
                    }
                }
            }
        }
Example #3
0
    private static Entity spawnNormalHelicopterForPlayer(Entity owner, Entity visual)
    {
        Vector3 pathStart = visual.Origin;
        Vector3 forward   = visual.Angles;
        Entity  heli      = SpawnHelicopter(owner, pathStart, forward, "cobra_mp", "vehicle_cobra_helicopter_fly_low");

        if (heli == null)
        {
            return(null);
        }

        heli.Health = 5000;
        heli.SetField("maxHealth", 5000);
        heli.SetField("damageTaken", 0);
        heli.SetField("ammo", 100);
        heli.SetField("missiles", 1);
        heli.SetField("lastMissileFire", GetTime());
        heli.SetField("pilot", owner);
        heli.SetField("visual", visual);

        heli.EnableLinkTo();
        heli.SetVehicleLookAtText("The Dickweed", "The Dickweed");
        //heli.MakeVehicleSolidSphere(96, -128);
        heli.SetSpeed(50, 20, 20);
        heli.SetHoverParams(20, 10, 5);
        heli.SetTurningAbility(.1f);
        heli.SetVehWeapon("cobra_20mm_mp");

        return(heli);
    }
Example #4
0
        public static void callHeliSniper(Entity owner, Vector3 location)
        {
            Vector3 pathStart;

            //shuffleStreaks(owner);
            if (heliHeight > location.Z && heliHeight - location.Z > 500)
            {
                pathStart = new Vector3(location.X - 10000, location.Y, heliHeight);
            }
            else
            {
                pathStart = location + new Vector3(-10000, 0, 2000);
            }

            Vector3 angles  = VectorToAngles(location - pathStart);
            Vector3 forward = AnglesToForward(angles);
            Entity  lb      = SpawnHelicopter(owner, pathStart, forward, "attack_littlebird_mp", "vehicle_little_bird_armed");

            //lb.MakeVehicleSolidSphere(128, 0);//Disabled to avoid trolling players

            lb.Angles = new Vector3(0, angles.Y, 0);
            lb.SetField("owner", owner);
            lb.SetVehicleTeam("allies");
            lb.EnableLinkTo();
            lb.SetSpeed(375, 225, 75);
            lb.SetHoverParams(5, 10, 5);
            lb.SetTurningAbility(1f);
            lb.SetYawSpeed(200, 75);
            lb.SetField("doneService", false);
            lb.SetField("heliTime", 120);
            lb.SetField("location", location);
            owner.SetField("ownsHeliSniper", false);
            StartAsync(heliSniper_flyIn(owner, lb, location));
            StartAsync(heliSniper_doBoarding(lb, owner));
        }
Example #5
0
        private static void spawnDragonfly(Entity owner, Vector3 pos, Vector3 angles)
        {
            hordeUtils.teamSplash("used_remote_uav", owner);
            owner.PlaySound("US_1mc_use_dragonfly");

            Entity uav = SpawnHelicopter(owner, pos + new Vector3(0, 0, 50), angles, "remote_uav_mp", "vehicle_remote_uav");

            uav.Angles = angles;
            uav.SetField("owner", owner);
            owner.SetField("ownedLittlebird", uav);
            uav.SetField("isAlive", true);
            uav.SetField("timeLeft", 60);
            uav.SetField("target", uav);
            uav.SetVehicleTeam("allies");
            uav.SetVehWeapon("remote_uav_weapon_mp");
            uav.SetSpeed(50, 15, 15);
            uav.SetTurningAbility(.5f);
            uav.SetYawSpeed(100, 50, 25);
            uav.SetHoverParams(10, 50, 25);
            //uav.SetVehicleLookAtText(owner.Name, "");
            uav.SetVehGoalPos(pos + new Vector3(0, 0, 50), true);
            uav.ClearTargetYaw();
            uav.ClearGoalYaw();

            OnInterval(1000, () => dragonfly_timer(uav));
            OnInterval(50, () => dragonfly_targeting(uav));
        }
 public override void Enter(Entity context)
 {
     transform = context.transform;
     direction = context.GetMedrashPosition() - transform.position;
     direction.y = 0.0f;
     context.SetSpeed(context.GetBaseSpeed()*1.5f);
     context.SetDirection(direction);
 }
Example #7
0
 public override void Enter(Entity context)
 {
     context.SetSpeed(0.0f);
     context.MakeInvunerable();
     context.SetDyingAnimation();
     if (context.blood)
         GameObject.Instantiate(context.blood, context.transform.position + Vector3.up*1.5f, context.transform.rotation);
 }
Example #8
0
        private static IEnumerator heliSniper_leave(Entity lb)
        {
            Vector3 location = lb.GetField <Vector3>("location");
            Entity  owner    = lb.GetField <Entity>("owner");

            lb.SetField("doneService", true);
            lb.SetSpeed(150, 50, 50);
            lb.SetVehGoalPos(new Vector3(location.X, location.Y, heliHeight), true);

            yield return(Wait(3));

            lb.SetVehGoalPos(location + new Vector3(0, 0, 200), true);

            yield return(Wait(3.05f));

            owner.EnableWeaponSwitch();
            owner.SwitchToWeapon(owner.GetField <string>("lastDroppableWeapon"));
            hordeUtils.updateAmmoHud(owner, true);
            owner.DisableWeaponSwitch();

            yield return(Wait(.75f));

            owner.TakeWeapon("iw5_as50_mp_as50scope");
            owner.Unlink();
            owner.EnableWeaponSwitch();
            owner.ResetSpreadOverride();
            owner.Player_RecoilScaleOff();
            owner.AllowSprint(true);
            owner.AllowJump(true);
            OnInterval(50, () => heliSniper_checkForPlayerClipping(owner));
            lb.ClearGoalYaw();
            lb.ClearTargetYaw();
            lb.SetVehGoalPos(lb.Origin + new Vector3(0, 0, 1800), true);

            yield return(Wait(5.05f));

            lb.SetSpeed(350, 225, 75);
            lb.SetVehGoalPos(lb.Origin + new Vector3(-100000, 0, 0), false);

            yield return(Wait(5));

            lb.FreeHelicopter();
            lb.Delete();
        }
Example #9
0
        private static void engageGround(Entity harrier)
        {
            harrier.Notify("engageGround");

            StartAsync(harrierGetTargets(harrier));
            StartAsync(randomHarrierMovement(harrier));

            Vector3 pathGoal = harrier.GetField <Vector3>("defendLoc");

            harrier.SetSpeed(15, 5);
            harrier.SetVehGoalPos(pathGoal, true);
        }
 public override void Enter(Entity context)
 {
     context.SetSpeed(context.GetBaseSpeed());
     float r = Random.value;
     rotateAngle = 120.0f*(2*r - 1)*Mathf.PI/180.0f;
     if (r < 0.4)
         context.RotateBy(rotateAngle);
     else if (r < 0.8)
         context.RotateBy(-rotateAngle);
     direction = context.transform.forward;
     direction.y = 0.0f;
     context.SetDirection(direction);
 }
Example #11
0
 public override void CompleteDominance(Entity entity)
 {
     //If both are dominant or recessive, then choose randomly
     if (AlleleA.Dominance == AlleleB.Dominance)
     {
         if (Random.Range(0, 2) == 0)
         {
             entity.SetSpeed(AlleleA.Walking, AlleleA.Running, AlleleA.Angular, AlleleA.Acceleration);
         }
         else
         {
             entity.SetSpeed(AlleleB.Walking, AlleleB.Running, AlleleB.Angular, AlleleB.Acceleration);
         }
     }
     else if (AlleleA.Dominance == Dominance.DOMINANT && AlleleB.Dominance != AlleleA.Dominance)
     {
         entity.SetSpeed(AlleleA.Walking, AlleleA.Running, AlleleA.Angular, AlleleA.Acceleration);
     }
     else
     {
         entity.SetSpeed(AlleleB.Walking, AlleleB.Running, AlleleB.Angular, AlleleB.Acceleration);
     }
 }
Example #12
0
        private static IEnumerator harrierLeave(Entity harrier)
        {
            harrier.SetMaxPitchRoll(0, 0);
            harrier.Notify("leaving");
            breakTarget(harrier, true);
            harrier.Notify("stopRand");

            for (;;)
            {
                harrier.SetSpeed(35, 25);
                Vector3 pathGoal = harrier.Origin + ((AnglesToForward(new Vector3(0, RandomInt(360), 0)) * 500));
                pathGoal += new Vector3(0, 0, 900);

                bool leaveTrace = BulletTracePassed(harrier.Origin, harrier.Origin + new Vector3(0, 0, 900), false, harrier);
                if (leaveTrace)
                {
                    break;
                }

                yield return(Wait(0.10f));
            }

            harrier.SetVehGoalPos(pathGoal, true);
            StartAsync(startHarrierWingFx(harrier));
            yield return(harrier.WaitTill("goal"));

            harrier.PlaySound("harrier_fly_away");
            Vector3 pathEnd = getPathEnd(harrier);

            harrier.SetSpeed(250, 75);
            yield return(harrier.WaitTill("goal"));

            //killstreaks.airPlane.Remove(harrier);

            harrier.Notify("harrier_gone");
            harrierDelete(harrier);
        }
Example #13
0
 public override void Enter(Entity context)
 {
     context.SetSpeed(context.GetBaseSpeed());
     context.SetRunAnimation();
 }
Example #14
0
        private void TakePerkCola(Entity player)
        {
            switch (Type)
            {
            case PerkColaType.QUICK_REVIVE:
                player.SetField("perk_revive", 0);
                break;

            case PerkColaType.SPEED_COLA:
                player.SetField("perk_speedcola", 0);
                player.DeletePerk("specialty_fastreload");
                player.DeletePerk("specialty_quickswap");
                player.DeletePerk("specialty_quickdraw");
                break;

            case PerkColaType.JUGGERNOG:
                player.SetField("perk_juggernog", 0);
                player.Call("setmodel", player.GetField <string>("oldmodel"));
                player.Call("setviewmodel", "viewmodel_base_viewhands");
                player.SetField("maxhealth", 100);
                player.Health = 100;
                break;

            case PerkColaType.STAMIN_UP:
                player.SetField("perk_staminup", 0);
                player.SetSpeed(1f);
                player.DeletePerk("specialty_marathon");
                player.DeletePerk("specialty_lightweight");
                player.DeletePerk("specialty_fastsprintrecovery");
                break;

            case PerkColaType.MULE_KICK:
                player.SetField("perk_mulekick", 0);
                player.GiveMaxAmmoWeapon(Sharpshooter._mulekickWeapon.Code);
                break;

            case PerkColaType.DOUBLE_TAP:
                player.SetField("perk_doubletap", 0);
                break;

            case PerkColaType.DEAD_SHOT:
                player.SetField("perk_deadshot", 0);
                player.DeletePerk("specialty_reducedsway");
                player.DeletePerk("specialty_bulletaccuracy");
                break;

            case PerkColaType.PHD:
                break;

            case PerkColaType.ELECTRIC_CHERRY:
                player.SetField("perk_cherry", 0);
                break;

            case PerkColaType.WIDOW_S_WINE:
                player.SetField("perk_widow", 0);
                break;

            case PerkColaType.VULTURE_AID:
                player.SetField("perk_vulture", 0);
                player.DeletePerk("specialty_scavenger");
                break;

            case PerkColaType.TOMBSTONE:
                player.SetField("perk_tombstone", 0);
                break;
            }
        }
Example #15
0
        private void GivePerkCola(Entity player)
        {
            switch (Type)
            {
            case PerkColaType.QUICK_REVIVE:
                player.SetField("perk_revive", 1);
                player.SetField("hasrevive", 1);
                break;

            case PerkColaType.SPEED_COLA:
                player.SetField("perk_speedcola", 1);
                player.SetPerk("specialty_fastreload", true, false);
                player.SetPerk("specialty_quickswap", true, false);
                player.SetPerk("specialty_quickdraw", true, false);
                player.SetPerk("specialty_armorpiercing", true, false);
                break;

            case PerkColaType.JUGGERNOG:
                player.SetField("perk_juggernog", 1);
                player.SetField("oldmodel", player.GetField <string>("model"));
                player.Call("setmodel", "mp_fullbody_ally_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_ally");
                player.SetField("maxhealth", 200);
                player.Health = 200;
                break;

            case PerkColaType.STAMIN_UP:
                player.SetField("perk_staminup", 1);
                player.SetSpeed(1.3f);
                player.SetPerk("specialty_marathon", true, false);
                player.SetPerk("specialty_lightweight", true, false);
                player.SetPerk("specialty_fastmantle", true, false);
                player.SetPerk("specialty_fastsprintrecovery", true, false);
                break;

            case PerkColaType.MULE_KICK:
                player.SetField("perk_mulekick", 1);
                player.GiveWeapon(Sharpshooter._mulekickWeapon.Code);
                player.Call("givemaxammo", Sharpshooter._mulekickWeapon.Code);
                break;

            case PerkColaType.DOUBLE_TAP:
                player.SetField("perk_doubletap", 1);
                break;

            case PerkColaType.DEAD_SHOT:
                player.SetField("perk_deadshot", 1);
                player.OnInterval(100, e =>
                {
                    player.Call("recoilscaleon", 0);
                    return(player.IsPlayer && player.IsAlive && player.HasPerkCola(Type));
                });
                player.SetPerk("specialty_reducedsway", true, false);
                player.SetPerk("specialty_bulletaccuracy", true, false);
                break;

            case PerkColaType.PHD:
                player.SetField("perk_phd", 1);
                player.SetPerk("_specialty_blastshield", true, false);
                player.SetPerk("specialty_throwback", true, false);
                break;

            case PerkColaType.ELECTRIC_CHERRY:
                player.SetField("perk_cherry", 1);
                break;

            case PerkColaType.WIDOW_S_WINE:
                player.SetField("perk_widow", 1);
                break;

            case PerkColaType.VULTURE_AID:
                player.SetField("perk_vulture", 1);
                Ammo.MaxAmmo(player);
                player.SetPerk("specialty_scavenger", true, false);
                break;

            case PerkColaType.TOMBSTONE:
                player.SetField("perk_tombstone", 1);
                player.SetField("hastombstone", 1);
                break;
            }
        }
Example #16
0
 public override void Enter(Entity context)
 {
     context.SetSpeed(0.0f);
     context.SetAttackAnimation();
 }
 public override void Enter(Entity context)
 {
     context.SetSpeed(8.0f);
 }
Example #18
0
 public override void IncompleteDominance(Entity entity)
 {
     entity.SetSpeed((AlleleA.Walking + AlleleB.Walking) / 2, (AlleleA.Running + AlleleB.Running) / 2,
                     (AlleleA.Angular + AlleleB.Angular) / 2, (AlleleA.Acceleration + AlleleB.Acceleration) / 2);
 }
 public override void Enter(Entity context)
 {
     context.SetSpeed(context.GetBaseSpeed());
 }
Example #20
0
        public void DoRolled(Entity player)
        {
            switch (Type)
            {
            case RollType.Nothing:
                break;

            case RollType.FlagZombie:
                player.SetField("rtd_flag", 1);
                player.Call("attach", GetCarryFlag(), "j_spine4", 1);
                break;

            case RollType.StaminUp:
                player.SetSpeed(1.5f);
                break;

            case RollType.OneHitKill:
                player.SetField("maxhealth", 1);
                player.Health = 1;
                break;

            case RollType.Juggernaut:
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 3);
                player.Health *= 3;
                break;

            case RollType.SMAW:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_smaw_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_smaw_mp"));
                break;

            case RollType.RPG:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("rpg_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("rpg_mp"));
                break;

            case RollType.Stinger:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("stinger_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("stinger_mp"));
                break;

            case RollType.AA12:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_aa12_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_aa12_mp"));
                break;

            case RollType.Spas:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_spas12_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_spas12_mp"));
                break;

            case RollType.Javelin:
                player.GiveMaxAmmoWeapon("javelin_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("javelin_mp"));
                break;

            case RollType.Riotshield:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("riotshield_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("riotshield_mp"));
                player.Call("attachshieldmodel", "weapon_riot_shield_mp", "tag_shield_back");
                break;

            case RollType.KingOfJuggernaut:
                player.SetField("rtd_king", 1);
                player.SetSpeed(0.7f);
                player.Call("attach", GetCarryFlag(), "j_spine4", 1);
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 10);
                player.Health *= 10;
                break;

            case RollType.DesertEagle:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_deserteagle_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_deserteagle_mp"));
                break;

            case RollType.ThrowingKnife:
                player.GiveWeapon("throwingknife_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("throwingknife_mp"));
                break;

            case RollType.FragGrenade:
                player.GiveWeapon("frag_grenade_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("frag_grenade_mp"));
                break;

            case RollType.M320:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("m320_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("m320_mp"));
                break;

            case RollType.XM25:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("xm25_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("xm25_mp"));
                break;

            case RollType.MK14:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_mk14_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_mk14_mp"));
                break;

            case RollType.SVD:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon(Utilities.BuildWeaponName("iw5_dragunov", "none", "none", 0, 0));
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate(Utilities.BuildWeaponName("iw5_dragunov", "none", "none", 0, 0)));
                break;

            case RollType.ISIS:
                player.SetField("rtd_isis", 1);
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("c4death_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("c4death_mp"));
                break;

            case RollType.ZombieIncantation:
                player.SetField("zombie_incantation", 1);
                break;

            case RollType.Tombstone:
                player.SetField("rtd_tombstone", 1);
                break;

            case RollType.Tank:
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 3);
                player.Health *= 3;
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("riotshield_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("riotshield_mp"));
                player.Call("attachshieldmodel", "weapon_riot_shield_mp", "tag_shield_back");
                break;

            case RollType.Boomer:
                player.SetField("rtd_boomer", 1);
                Utility.SetZombieSniperModel(player);
                break;

            case RollType.Spider:
                player.SetField("rtd_spider", 1);
                Utility.SetZombieSniperModel(player);
                break;

            case RollType.Somker:
                player.SetField("rtd_somker", 1);
                Utility.SetZombieSniperModel(player);
                break;

            case RollType.JetPack:
                player.SetField("rtd_exo", 1);
                break;

            case RollType.IceZombie:
                player.SetField("rtd_ice", 1);
                break;

            case RollType.ExtendedMelee:
                player.SetPerk("specialty_extendedmelee", true, true);
                break;

            case RollType.MysteryZombie:
                player.SetField("rtd_mystery", 1);
                break;

            case RollType.Darkness:
                player.SetField("rtd_vision", 1);
                player.Notify("vision", "cheat_chaplinnight");
                break;

            case RollType.Negative:
                player.SetField("rtd_vision", 1);
                player.Notify("vision", "cheat_invert_contrast");
                break;

            case RollType.Fallout:
                player.SetField("rtd_vision", 1);
                player.Notify("vision", "mpnuke");
                break;

            case RollType.Nightvision:
                player.SetField("rtd_vision", 1);
                player.Notify("vision", "default_night_mp");
                break;

            case RollType.Late:
                player.SetField("rtd_vision", 1);
                player.Notify("vision", "cobra_sunset3");
                break;

            case RollType.GodMode:
                player.Health = -1;
                player.AfterDelay(5000, e => player.Health = player.GetField <int>("maxhealth"));
                break;

            case RollType.Die:
                player.AfterDelay(5000, e => player.Notify("self_exploed"));
                break;

            case RollType.PhD:
                player.SetField("rtd_phd", 1);
                player.SetPerk("_specialty_blastshield", true, false);
                player.SetPerk("specialty_throwback", true, false);
                break;

            case RollType.MSR:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon(Utilities.BuildWeaponName("iw5_msr", "none", "none", 0, 0));
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate(Utilities.BuildWeaponName("iw5_msr", "none", "none", 0, 0)));
                break;

            case RollType.Tesla:
                player.SetField("rtd_tesla", 1);
                break;

            case RollType.WalkingDeath:
                player.TakeWeapon(player.CurrentWeapon);
                break;

            case RollType.CopyCat:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon(Sharpshooter._firstWeapon.Code);
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate(Sharpshooter._firstWeapon.Code));
                break;

            case RollType.DeathMachine:
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveMaxAmmoWeapon("iw5_m60jugg_mp_eotechlmg_rof_camo08");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("iw5_m60jugg_mp_eotechlmg_rof_camo08"));
                break;

            case RollType.ISISJuggernaut:
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 3);
                player.Health *= 3;
                player.SetField("rtd_isis", 1);
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("c4death_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("c4death_mp"));
                break;

            case RollType.JetPackJuggernaut:
                player.SetField("rtd_isis", 1);
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("c4death_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("c4death_mp"));
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 3);
                player.Health *= 3;
                break;

            case RollType.JetPackISIS:
                player.SetField("rtd_isis", 1);
                player.TakeWeapon(player.CurrentWeapon);
                player.GiveWeapon("c4death_mp");
                player.AfterDelay(300, e => player.SwitchToWeaponImmediate("c4death_mp"));
                player.SetField("rtd_exo", 1);
                break;

            case RollType.TeslaJuggernaut:
                player.Call("setmodel", "mp_fullbody_opforce_juggernaut");
                player.Call("setviewmodel", "viewhands_juggernaut_opforce");
                player.SetField("maxhealth", player.GetField <int>("maxhealth") * 3);
                player.Health *= 3;
                player.SetField("rtd_tesla", 1);
                break;

            case RollType.Tyrant:
                player.SetSpeed(1.5f);
                player.SetField("rtd_exo", 1);
                player.SetPerk("specialty_extendedmelee", true, true);
                break;
            }
        }