Example #1
0
        private static void updateThrusterBar(Entity player, int percentage)
        {
            HudElem thrusterBar = player.GetField <HudElem>("hud_thrusterBar");

            thrusterBar.FadeOverTime(1);
            thrusterBar.Alpha = 1;
            thrusterBar.Parent.FadeOverTime(.5f);
            thrusterBar.Parent.Alpha = .2f;
            thrusterBar.ScaleOverTime(.5f, percentage * 4, 3);
            AfterDelay(2000, () =>
            {
                int thrusterEnergy = player.GetField <int>("thrusterEnergy");
                if (thrusterEnergy >= 25)
                {
                    //HudElem thrusterBar = p.GetField<HudElem>("hud_thrusterBar");
                    if (thrusterBar.Alpha == 1)
                    {
                        thrusterBar.FadeOverTime(.5f);
                        thrusterBar.Alpha = 0;
                        thrusterBar.Parent.FadeOverTime(1);
                        thrusterBar.Parent.Alpha = 0;
                    }
                }
            });
        }
Example #2
0
        private static void updateStreakSlot(Entity player, int slot, string streak)
        {
            string[] killstreakList = player.GetField <string[]>("killstreaks");
            killstreakList[slot] = streak;
            player.SetField("killstreaks", new Parameter(killstreakList));
            if (streak == "")
            {
                player.SetActionSlot(slot + 4, "");
            }

            //Set the HUD for this
            string[] streaks = player.GetField <string[]>("streakSlotText");
            if (streak == "")
            {
                streaks[slot] = "";
            }
            else
            {
                streaks[slot] = hordeUtils.createHudShaderString(horde.killstreakIcons[streak]) + "[{+actionslot " + (slot + 4) + "}]";
            }

            if (!player.HasField("hud_created"))
            {
                return;
            }

            HudElem list    = player.GetField <HudElem>("hud_killstreakList");
            string  newText = streaks[0] + "\n\n" + streaks[1] + "\n\n" + streaks[2] + "\n\n" + streaks[3];

            player.SetField("streakSlotText", new Parameter(streaks));
            list.SetText(newText);
        }
Example #3
0
        public Entity[] CreateTeleporter(Vector3 origin, Vector3 angle, Vector3 endorigin)
        {
            Call("precacheshader", new Parameter[] { "hudicon_neutral" });
            Entity box = Call <Entity>("spawn", new Parameter[] { "script_model", new Parameter(origin) });

            box.Call("setmodel", new Parameter[] { "com_plasticcase_friendly" });
            box.SetField("angles", new Parameter(angle));
            box.Call("clonebrushmodeltoscriptmodel", new Parameter[] { _airdropCollision });
            box.SetField("endorigin", endorigin);
            Vector3 v = origin;

            v.Z += 17f;
            Entity laptop = Call <Entity>("spawn", new Parameter[] { "script_model", new Parameter(v) });

            laptop.Call("setmodel", new Parameter[] { "com_laptop_2_open" });
            LaptopRotate(laptop);
            HudElem elem = HudElem.NewHudElem();

            elem.SetShader("hudicon_neutral", 20, 20);
            elem.X = box.Origin.X;
            elem.Y = box.Origin.Y;
            elem.Z = box.Origin.Z + 40f;
            elem.Call("SetWayPoint", new Parameter[] { 1, 1 });
            int num = 0x1f - curObjID++;

            Call("objective_state", new Parameter[] { num, "active" });
            Call("objective_position", new Parameter[] { num, new Parameter(origin) });
            Call("objective_icon", new Parameter[] { num, "hudicon_neutral" });

            return(new Entity[] { box });
        }
Example #4
0
        private void Credits(Entity ent)
        {
            HudElem credits = HudElem.CreateFontString(ent, "hudbig", 1.0f);

            credits.SetPoint("CENTER", "BOTTOM", 0, -70);
            credits.Call("settext", "CHINA Magic Infect Extreme Edition");
            credits.Alpha = 0f;
            credits.SetField("glowcolor", new Vector3(1f, 0.5f, 1f));
            credits.GlowAlpha = 1f;

            HudElem credits2 = HudElem.CreateFontString(ent, "hudbig", 0.6f);

            credits2.SetPoint("CENTER", "BOTTOM", 0, -90);
            credits2.Call("settext", "Vesion 1.1.7 Code in: github.com/A2ON");
            credits2.Alpha = 0f;
            credits2.SetField("glowcolor", new Vector3(1f, 0.5f, 1f));
            credits2.GlowAlpha = 1f;

            ent.OnNotify("tab", entity =>
            {
                credits.Alpha  = 1f;
                credits2.Alpha = 1f;
            });

            ent.OnNotify("-tab", entity =>
            {
                credits.Alpha  = 0f;
                credits2.Alpha = 0f;
            });
        }
Example #5
0
        private static void StaticEffect(Entity player, int duration)
        {
            if (!player.IsPlayer)
            {
                return;
            }

            HudElem staticBG = NewClientHudElem(player);

            staticBG.HorzAlign = HudElem.HorzAlignments.Fullscreen;
            staticBG.VertAlign = HudElem.VertAlignments.Fullscreen;
            staticBG.SetShader("white", 640, 480);
            staticBG.Archived = true;
            staticBG.Sort     = 10;

            HudElem staticFG = NewClientHudElem(player);

            staticFG.HorzAlign = HudElem.HorzAlignments.Fullscreen;
            staticFG.VertAlign = HudElem.VertAlignments.Fullscreen;
            staticFG.SetShader("ac130_overlay_grain", 640, 480);
            staticFG.Archived = true;
            staticFG.Sort     = 20;

            AfterDelay(duration, () =>
            {
                staticFG.Destroy();
                staticBG.Destroy();
            });
        }
Example #6
0
        public void scoreHUD(Entity player, int amount)
        {
            HudElem score = HudElem.CreateFontString(player, "hudsmall", 1.2f);

            score.SetPoint("CENTER", "CENTER");
            if (amount < 0)
            {
                score.Color = new Vector3(.6f, .2f, .2f);
                score.SetText("-" + amount);
            }
            else
            {
                score.Color = new Vector3(.2f, .6f, .2f);
                score.SetText("+" + amount);
            }
            score.Alpha = 0;
            score.Call("fadeovertime", .1f);
            score.Alpha = 1;
            AfterDelay(2000, () =>
            {
                score.Call("fadeovertime", .1f);
                score.Alpha = 0;
                AfterDelay(200, () =>
                           score.Call("destroy"));
            });
        }
Example #7
0
    private static bool isCursorHoveringButton(Entity player, Button button)
    {
        HudElem cursor  = player.GetField <HudElem>("cursor");
        float   cursorX = cursor.X;
        float   cursorY = cursor.Y;

        if (cursorX - 360 > (button.X + (button.Width / 2)))
        {
            return(false);
        }
        if (cursorX - 360 < (button.X - (button.Width / 2)))
        {
            return(false);
        }
        if (cursorY > (button.Y + (button.Height / 2)))
        {
            return(false);
        }
        if (cursorY < (button.Y - (button.Height / 2)))
        {
            return(false);
        }

        return(true);
    }
Example #8
0
        public static HudElem PerkHud(this Entity player, PerkCola perk, bool playsound = false)
        {
            player.Call("setblurforplayer", 6, 0.5f);
            int perksAmount   = player.PerkColasCount() - 1;
            int MultiplyTimes = 28 * perksAmount;

            var hudtext = HudElem.NewClientHudElem(player);

            hudtext.AlignX     = "center";
            hudtext.VertAlign  = "middle";
            hudtext.AlignY     = "middle";
            hudtext.HorzAlign  = "center";
            hudtext.Font       = "objective";
            hudtext.FontScale  = 1.5f;
            hudtext.X          = 0;
            hudtext.Y          = 0;
            hudtext.Foreground = true;
            hudtext.Color      = perk.HudColor;
            hudtext.Alpha      = 0;
            hudtext.SetText(perk.HudName);

            var hudshader = HudElem.NewClientHudElem(player);

            hudshader.AlignX     = "center";
            hudshader.VertAlign  = "middle";
            hudshader.AlignY     = "middle";
            hudshader.HorzAlign  = "center";
            hudshader.X          = 0;
            hudshader.Y          = 0;
            hudshader.Foreground = true;
            hudshader.SetShader(perk.Icon, 25, 25);
            hudshader.Alpha = 1;
            hudshader.SetField("perk", new Parameter(perk.Type));

            player.AfterDelay(300, e =>
            {
                hudshader.Call("moveovertime", 0.5f);
                hudshader.X = -200;
            });
            player.AfterDelay(700, e =>
            {
                player.Call("setblurforplayer", 0, 0.3f);
                hudtext.Alpha = 1;
            });
            player.AfterDelay(3700, e =>
            {
                hudtext.Call("fadeovertime", 0.25f);
                hudtext.Alpha = 0;
                hudshader.Call("scaleovertime", 1, 25, 25);
                hudshader.Call("moveovertime", 1);
                hudshader.X = -300 + MultiplyTimes;
                hudshader.Y = 180;
            });
            player.AfterDelay(4700, e =>
            {
                hudtext.Call("destroy");
            });

            return(hudshader);
        }
Example #9
0
        public motd() : base()
        {
            base.Call("setdvar", new Parameter[]
            {
                "motd",
                "Wilkommen auf unseren Server da wir das LSD Script gleakt haben müssen wir natürlich alles erstmal zum laufen bekommen. Für Fehler entschuldigen wir uns! BAN SYSTEN = NOTHING"
            });
            HudElem motd = HudElem.CreateServerFontString("boldFont", 1f);

            motd.SetPoint("CENTER", "BOTTOM", 0, -19);
            motd.Foreground     = true;
            motd.HideWhenInMenu = true;
            base.OnInterval(25000, delegate
            {
                motd.SetText(this.Call <string>("getdvar", new Parameter[]
                {
                    "motd"
                }));
                motd.SetPoint("CENTER", "BOTTOM", 1100, -10);
                motd.Call("moveovertime", new Parameter[]
                {
                    25
                });
                motd.X = -700f;
                return(true);
            });
        }
Example #10
0
    private static void closeTestMenu(Entity player)
    {
        player.AllowAds(true);
        player.AllowJump(true);
        player.AllowSprint(true);
        player.SetMoveSpeedScale(1);
        player.EnableOffhandWeapons();
        player.EnableUsability();
        player.EnableWeaponPickup();
        player.EnableWeapons();
        player.EnableWeaponSwitch();
        //player.SetClientDvar("ui_drawCrosshair", "1");
        player.SetClientDvar("g_hardcore", "0");
        player.SetClientDvar("g_scriptMainMenu", "class");
        player.ClearField("hoveredButton");

        HudElem cursor = player.GetField <HudElem>("cursor");

        cursor.FadeOverTime(.25f);
        cursor.Alpha = 0;

        foreach (HudElem hud in player.GetField <List <HudElem> >("menu"))
        {
            hud.FadeOverTime(.25f);
            hud.Alpha = 0;
            AfterDelay(250, () => hud.Destroy());
        }
        foreach (Button button in Button.menuButtons)
        {
            button.hud       = null;
            button.isHovered = false;
        }

        player.SetField("menuOpen", false);
    }
Example #11
0
        public static void GamblerText(this Entity player, string text, Vector3 color, Vector3 glowColor, float intensity, float glowIntensity)
        {
            var hud = HudElem.CreateFontString(player, "hudbig", 2);

            hud.SetPoint("CENTERMIDDLE", "CENTERMIDDLE", 0, 0);
            hud.SetText(text);
            hud.Color     = color;
            hud.GlowColor = glowColor;
            hud.Alpha     = 0;
            hud.GlowAlpha = glowIntensity;

            hud.ChangeFontScaleOverTime(0.25f, 0.75f);
            hud.Call("FadeOverTime", 0.25f);
            hud.Alpha = intensity;

            player.AfterDelay(250, ent => player.Call("playLocalSound", "mp_bonus_end"));

            player.AfterDelay(3000, ent =>
            {
                hud.ChangeFontScaleOverTime(0.25f, 2f);
                hud.Call("FadeOverTime", 0.25f);
                hud.Alpha = 0;
            });

            player.AfterDelay(4000, ent => hud.Call("destroy"));
        }
Example #12
0
        public void spawn(Entity player)
        {
            /*(player.SpawnedPlayer += new Action(() =>
             * {
             *  player.Health = 500;
             * });*/

            HudElem LabelA = HudElem.CreateFontString(player, "hudbig", 0.8f);

            LabelA.SetPoint("TOPRIGHT", "TOPRIGHT", -60, 10);
            LabelA.SetText("^0L^1S^3D^2 Snipe");
            LabelA.HideWhenInMenu = true;

            HudElem LabelC = HudElem.CreateFontString(player, "hudbig", 0.5f);

            LabelC.SetPoint("TOPRIGHT", "TOPRIGHT", -60, 30);
            LabelC.SetText("^5TS3: ^2codeascript.de");
            LabelC.HideWhenInMenu = true;

            HudElem LabelB = HudElem.CreateFontString(player, "hudbig", 0.8f);

            LabelB.SetPoint("TOPRIGHT", "TOPRIGHT", -60, 60);
            LabelB.SetText("...");
            LabelB.HideWhenInMenu = true;

            OnInterval(50, () =>
            {
                LabelB.SetText(DateTime.Now.ToShortTimeString());
                return(true);
            });
        }
Example #13
0
        public void StartAC130(Entity player)
        {
            player.TeamPlayerCardSplash("used_ac130", "ac130");

            player.GiveWeapon("ac130_105mm_mp");
            player.GiveWeapon("ac130_40mm_mp");
            player.GiveWeapon("ac130_25mm_mp");
            player.SwitchToWeapon("ac130_105mm_mp");

            player.Call("SetPlayerData", "ac130Ammo105mm", player.Call <int>("GetWeaponAmmoClip", "ac130_105mm_mp"));
            player.Call("SetPlayerData", "ac130Ammo40mm", player.Call <int>("GetWeaponAmmoClip", "ac130_40mm_mp"));
            player.Call("SetPlayerData", "ac130Ammo25mm", player.Call <int>("GetWeaponAmmoClip", "ac130_25mm_mp"));

            player.Call("ThermalVisionFOFOverlayOn");

            AttachPlayer(player);
            WeaponFiredThread(player);
            ShotFired(player);

            Dictionary <string, HudElem> overlay = Overlay(player);
            HudElem timer = Timer(player, Duration);

            AC130UseWaiter(player, overlay, timer);

            ThermalVision(player, overlay);
        }
Example #14
0
        private static IEnumerator useHoldThink(Entity box, Entity player, int useTime)
        {
            player.LinkTo(box);
            player.PlayerLinkedOffsetEnable();

            player.DisableWeapons();

            player.SetField("boxParams_useTime", useTime);

            HudElem bar = killstreaks.createPrimaryProgressBar(player, 0, 0, boxSettings[box.GetField <string>("boxType")]["capturingString"]);

            bool result = false;

            useHoldThinkLoop(player, (r) => result = r);
            killstreaks.updateBar(bar, 120, 2);

            yield return(player.WaitTill("useHoldThinkLoop_done"));

            killstreaks.destroyPrimaryProgressBar(bar);

            if (player.IsAlive)
            {
                player.EnableWeapons();
                player.Unlink();
            }

            if (result)
            {
                player.Notify("useHoldThink_captured");
            }
            else
            {
                player.Notify("useHoldThink_cancelled");
            }
        }
Example #15
0
    public void startHUD()
    {
        HudElem primed = HudElem.CreateServerFontString(HudElem.Fonts.HudBig, 1);

        primed.SetPoint("TOP RIGHT", "TOPRIGHT", -45, 5);
        primed.HideWhenInMenu = true;
        primed.SetText("Primed Players:");
        primed.GlowAlpha = 0.10f;
        primed.GlowColor = new Vector3(0, 0, 0.7f);

        HudElem number = HudElem.CreateServerFontString(HudElem.Fonts.HudBig, 1);

        number.SetPoint("TOP RIGHT", "TOPRIGHT", -5, 5);
        number.HideWhenInMenu = true;
        OnInterval(100, () =>
        {
            number.SetValue(Primers.Count);
            if (Primers.Count == 0)
            {
                return(false);
            }
            return(true);
        });
        number.GlowAlpha = 0.10f;
        number.GlowColor = new Vector3(0, 0, 0.7f);
    }
Example #16
0
        public static void updateWeaponLevel(Entity player, string weapon, bool updateLevelNumber = false)
        {
            string  baseWeapon         = getBaseWeaponName(weapon);
            HudElem weaponLevelBar     = player.GetField <HudElem>("hud_weaponLevelBar");
            HudElem weaponLevelCounter = player.GetField <HudElem>("hud_weaponIcon").Children[0];

            if (!horde.weaponNames.ContainsKey(baseWeapon))
            {
                weaponLevelBar.ScaleOverTime(.3f, 0, 18);
                weaponLevelCounter.SetValue(0);
                return;
            }

            int   weaponLevelValue = horde.weaponLevelValues[player.EntRef][baseWeapon];
            float percent          = weaponLevelValue / (float)horde.maxWeaponLevelValue;

            if (percent < .05f)
            {
                percent = .05f;
            }
            weaponLevelBar.ScaleOverTime(.3f, (int)(percent * (int)weaponLevelBar.GetField("maxWidth")), 18);
            if (updateLevelNumber)
            {
                int weaponLevel = horde.weaponLevels[player.EntRef][baseWeapon];
                weaponLevelCounter.SetValue(weaponLevel);
            }
        }
Example #17
0
        public void UsablesHud(Entity player)
        {
            HudElem message = HudElem.CreateFontString(player, "hudbig", 0.6f);

            message.SetPoint("CENTER", "CENTER", 0, -50);
            OnInterval(100, () =>
            {
                bool _changed = false;
                foreach (Entity ent in usables)
                {
                    if (player.Origin.DistanceTo(ent.Origin) < ent.GetField <int>("range"))
                    {
                        switch (ent.GetField <string>("usabletype"))
                        {
                        case "door":
                            message.SetText(getDoorText(ent, player));
                            break;

                        default:
                            message.SetText("");
                            break;
                        }
                        _changed = true;
                    }
                }
                if (!_changed)
                {
                    message.SetText("");
                }
                return(true);
            });
        }
Example #18
0
 private void permKill()
 {
     info = HudElem.CreateServerFontString(HudElem.Fonts.HudBig, 1.4f);
     info.SetPoint("TOPCENTER", "TOPCENTER", 0, -15);
     info.HideWhenInMenu = true;
     info.SetText("^1Kill Mike!");
 }
Example #19
0
        public static void onPlayerSpawned(Entity player)
        {
            updateHUDAmmo(player, true);
            player.GiveWeapon("killstreak_double_uav_mp");
            if (player.HasWeapon("smoke_grenade_mp") && player.HasPerk("specialty_tacticalinsertion"))
            {
                player.SetOffhandPrimaryClass("flash");
            }
            if (player.HasWeapon("iw5_smaw_mp"))
            {
                player.TakeWeapon("iw5_smaw_mp");
                player.GiveWeapon("at4_mp");
            }

            if (player.HasField("scoreArrow"))
            {
                HudElem arrow = player.GetField <HudElem>("scoreArrow");
                int     y     = -24;
                if (isTeamBased && player.SessionTeam == "axis")
                {
                    y = -38;
                }
                arrow.SetPoint("BOTTOMLEFT", "BOTTOMLEFT", 82, y);
                arrow.Alpha             = 1;
                arrow.Children[0].Alpha = 1;
            }
        }
Example #20
0
        private static void destroyBlastShieldOverlay(Entity player)
        {
            HudElem overlay = player.GetField <HudElem>("hud_overlay");

            overlay.Destroy();
            player.ClearField("hud_overlay");
        }
Example #21
0
        public GTA5Wasted()
        {
            PlayerConnected += delegate(Entity player)
            {
                HudElem hud = HudElem.CreateFontString(player, "hudbig", 2.3f);
                hud.SetPoint("center", "center", 0, -20);
                hud.SetText("Wasted");
                hud.Color     = new Vector3(255f, 0f, 0f);
                hud.GlowColor = new Vector3(0.2f, 0.2f, 0.2f);
                hud.GlowAlpha = 0.8f;
                hud.Alpha     = 0f;

                HudElem overlay = HudElem.CreateIcon(player, "combathigh_overlay", 640, 480);
                overlay.X         = 0f;
                overlay.Y         = 0f;
                overlay.AlignX    = "left";
                overlay.AlignY    = "top";
                overlay.HorzAlign = "fullscreen";
                overlay.VertAlign = "fullscreen";
                overlay.Color     = new Vector3(0.2f, 0.2f, 0.2f);
                overlay.Alpha     = 0f;

                player.SetField("gta5_hud", new Parameter(hud));
                player.SetField("gta5_overlay", new Parameter(overlay));
                player.SetField("gta5_dead", 0);

                player.SpawnedPlayer += delegate
                {
                    hud.Alpha     = 0f;
                    overlay.Alpha = 0f;

                    player.SetField("gta5_dead", 0);
                };
            };
        }
Example #22
0
        public override void OnPlayerKilled(Entity player, Entity inflictor, Entity attacker, int damage, string mod, string weapon, Vector3 dir, string hitLoc)
        {
            HudElem Hud = player.GetField <HudElem>("gta5_hud");

            Hud.Alpha = 0.7f;

            HudElem Overlay = player.GetField <HudElem>("gta5_overlay");

            Overlay.Call("fadeovertime", 1f);
            Overlay.Alpha = 1f;

            player.SetField("gta5_dead", 1);
            OnInterval(10, () =>
            {
                player.Call("setempjammed", true);
                //player.Call("visionsetnakedforplayer", "mpIntro", 1);
                if (player.IsAlive)
                {
                    //player.Call("visionsetnakedforplayer", "", 1);
                    player.Call("setempjammed", false);
                }

                return(player.GetField <int>("gta5_dead") != 0);
            });
        }
Example #23
0
    private void aliveCounter(Entity player)
    {
        HudElem fontString1 = HudElem.CreateFontString(player, "hudbig", 0.6f);

        fontString1.SetPoint("DOWNRIGHT", "DOWNRIGHT", -19, 60);
        fontString1.SetText("^5Allies^7:");
        fontString1.HideWhenInMenu = true;
        HudElem fontString2 = HudElem.CreateFontString(player, "hudbig", 0.6f);

        fontString2.SetPoint("DOWNRIGHT", "DOWNRIGHT", -19, 80);
        fontString2.SetText("^1Enemy^7:");
        fontString2.HideWhenInMenu = true;
        HudElem hudElem2 = HudElem.CreateFontString(player, "hudbig", 0.6f);

        hudElem2.SetPoint("DOWNRIGHT", "DOWNRIGHT", -8, 60);
        hudElem2.HideWhenInMenu = true;
        HudElem hudElem3 = HudElem.CreateFontString(player, "hudbig", 0.6f);

        hudElem3.SetPoint("DOWNRIGHT", "DOWNRIGHT", -8, 80);
        hudElem3.HideWhenInMenu = true;
        this.OnInterval(50, (Func <bool>)(() =>
        {
            string str1 = (string)player.GetField <string>("sessionteam");
            string str2 = ((int)this.Call <int>("getteamplayersalive", "axis")).ToString();
            string str3 = ((int)this.Call <int>("getteamplayersalive", "allies")).ToString();
            hudElem2.SetText(str1.Equals("allies") ? str3 : str2);
            hudElem3.SetText(str1.Equals("allies") ? str2 : str3);
            return(true);
        }));
    }
Example #24
0
        private static IEnumerator staticEffect(Entity player, float duration)
        {
            if (player.Classname != "player")
            {
                yield return(null);
            }

            HudElem staticBG = NewClientHudElem(player);

            staticBG.HorzAlign = HudElem.HorzAlignments.Fullscreen;
            staticBG.VertAlign = HudElem.VertAlignments.Fullscreen;
            staticBG.SetShader("white", 640, 480);
            staticBG.Archived = true;
            staticBG.Sort     = 10;

            HudElem staticFG = NewClientHudElem(player);

            staticFG.HorzAlign = HudElem.HorzAlignments.Fullscreen;
            staticFG.VertAlign = HudElem.VertAlignments.Fullscreen;
            staticFG.SetShader("ac130_overlay_grain", 640, 480);
            staticFG.Archived = true;
            staticFG.Sort     = 20;

            yield return(Wait(duration));

            staticFG.Destroy();
            staticBG.Destroy();

            yield break;
        }
Example #25
0
        private void MakeHUD(Entity player)
        {
            HudElem screen = HudElem.NewClientHudElem(player);

            screen.X         = 0f;
            screen.Y         = 0f;
            screen.AlignX    = "left";
            screen.AlignY    = "top";
            screen.HorzAlign = "fullscreen";
            screen.VertAlign = "fullscreen";
            screen.SetShader("remote_turret_overlay_mp", 640, 480);
            screen.Sort     = -10;
            screen.Archived = true;

            OnInterval(100, () =>
            {
                if (player.GetField <int>("isjet") == 0)
                {
                    screen.Alpha = 0f;
                }
                else
                {
                    screen.Alpha = 1f;
                }

                return(player != null);
            });
        }
Example #26
0
        public static void Credits(this Entity player)
        {
            HudElem credits = HudElem.CreateFontString(player, "hudbig", 1.0f);

            credits.SetPoint("CENTER", "BOTTOM", 0, -70);
            credits.Call("settext", "Project Cirno (INF3) for FFA");
            credits.Alpha = 0f;
            credits.SetField("glowcolor", new Vector3(1f, 0.5f, 1f));
            credits.GlowAlpha = 1f;

            HudElem credits2 = HudElem.CreateFontString(player, "hudbig", 0.6f);

            credits2.SetPoint("CENTER", "BOTTOM", 0, -90);
            credits2.Call("settext", "Vesion 1.0. Code in: https://github.com/A2ON");
            credits2.Alpha = 0f;
            credits2.SetField("glowcolor", new Vector3(1f, 0.5f, 1f));
            credits2.GlowAlpha = 1f;

            player.Call("notifyonplayercommand", "tab", "+scores");
            player.OnNotify("tab", entity =>
            {
                credits.Alpha  = 1f;
                credits2.Alpha = 1f;
            });

            player.Call("notifyonplayercommand", "-tab", "-scores");
            player.OnNotify("-tab", entity =>
            {
                credits.Alpha  = 0f;
                credits2.Alpha = 0f;
            });
        }
Example #27
0
        public void SharpShooter_Tick()
        {
            var _cycleTitle = HudElem.CreateServerFontString("objective", 1.4f);

            _cycleTitle.SetPoint("TOPLEFT", "TOPLEFT", 115, 5);
            _cycleTitle.HideWhenInMenu = true;
            _cycleTitle.SetText("Weapon Cycling: ");

            _cycleTimer = HudElem.CreateServerFontString("objective", 1.4f);
            _cycleTimer.SetPoint("TOPLEFT", "TOPLEFT", 255, 5);
            _cycleTimer.HideWhenInMenu = true;

            _cycleTimer.Call("settimer", _cycleRemaining - 1);

            OnInterval(1000, () =>
            {
                _cycleRemaining--;

                if (_cycleRemaining <= 0)
                {
                    _cycleRemaining = Utility.Random.Next(45, 90);
                    _cycleTimer.Call("settimer", _cycleRemaining);

                    UpdateWeapon();
                }

                return(true);
            });
        }
Example #28
0
        public static Dictionary <string, HudElem> CreateBar(this Entity self, byte width = 120, byte height = 9)
        {
            HudElem backGround = HudElem.CreateIcon(self, "black", width, height);

            backGround.SetPoint("center left", "center", -61, 0);
            backGround.Sort  = -3;
            backGround.Alpha = 0;

            HudElem whiteProgres = HudElem.CreateIcon(self, "progress_bar_bg", 1, height - 3);

            whiteProgres.SetPoint("center left", "center", -60, 0);
            whiteProgres.Sort  = -2;
            whiteProgres.Color = new Vector3(1, 1, 1);
            whiteProgres.Alpha = 0;

            HudElem textCapturing = HudElem.CreateFontString(self, "HudSmall", 0.8f);

            textCapturing.SetPoint("center", "center", 0, -12);
            textCapturing.SetText("Capturing...");
            textCapturing.Sort  = -1;
            textCapturing.Color = new Vector3(1, 1, 1);
            textCapturing.Alpha = 0;

            return(new Dictionary <string, HudElem>()
            {
                { "BackGround", backGround },
                { "Progress", whiteProgres },
                { "Text", textCapturing }
            });
        }
Example #29
0
        public Dictionary <string, HudElem> Overlay(Entity player)
        {
            Dictionary <string, HudElem> overlay = new Dictionary <string, HudElem>()
            {
                ["thermal_vision"]  = HudElem.NewClientHudElem(player),
                ["enhanced_vision"] = HudElem.NewClientHudElem(player)
            };

            overlay["thermal_vision"].X         = 200;
            overlay["thermal_vision"].Y         = 0;
            overlay["thermal_vision"].AlignX    = "left";
            overlay["thermal_vision"].AlignY    = "top";
            overlay["thermal_vision"].HorzAlign = "left";
            overlay["thermal_vision"].VertAlign = "top";
            overlay["thermal_vision"].FontScale = 2.5f;
            overlay["thermal_vision"].SetText("FLIR");
            overlay["thermal_vision"].Alpha = 1;

            overlay["enhanced_vision"].X         = -200;
            overlay["enhanced_vision"].Y         = 0;
            overlay["enhanced_vision"].AlignX    = "right";
            overlay["enhanced_vision"].AlignY    = "top";
            overlay["enhanced_vision"].HorzAlign = "right";
            overlay["enhanced_vision"].VertAlign = "top";
            overlay["enhanced_vision"].FontScale = 2.5f;
            overlay["enhanced_vision"].SetText("OPT");
            overlay["enhanced_vision"].Alpha = 1;

            player.Call("setBlurForPlayer", 1.2f, 0);

            return(overlay);
        }
Example #30
0
 public override void OnPlayerKilled(Entity player, Entity inflictor, Entity attacker, int damage, string mod, string weapon, Vector3 dir, string hitLoc)
 {
     if (player.HasField("KStreak") && attacker.HasField("KStreak"))
     {
         if (player != attacker)
         {
             attacker.SetField("KStreak", attacker.GetField <int>("KStreak") + 1);
         }
         player.SetField("KStreak", 0);
         HudElem elem = NoKillsHuds[attacker.Call <int>("getentitynumber")];
         if (elem == null)
         {
             throw new Exception("AttackerNoKills is null. Attacker: " + attacker.Name);
         }
         elem.SetText("^3" + attacker.GetField <int>("KStreak").ToString());
         NoKillsHuds[attacker.Call <int>("getentitynumber")] = elem;
         HudElem elem2 = NoKillsHuds[player.Call <int>("getentitynumber")];
         if (elem2 == null)
         {
             throw new Exception("VictimNoKills is null. Victim: " + player.Name);
         }
         elem2.SetText("0");
         NoKillsHuds[player.Call <int>("getentitynumber")] = elem2;
     }
 }
Example #31
0
        private void CreatePerkHUD(Entity player)
        {
            var icons = new HudElem[3];

            new[] { -300, -250, -200 }.ToList().ForEach(y =>
            {
                var i = (y + 300) / 50;

                var elem = HudElem.CreateIcon(player, "specialty_quickdraw_upgrade", 40, 40);
                elem.SetPoint("bottom right", "bottom right", -120, y);
                elem.Alpha = 0;
                elem.HideWhenInMenu = true;
                elem.Foreground = true;

                icons[i] = elem;
            });

            player.SetField("shrp_perkIcons", new Parameter(icons));

            var names = new HudElem[3];

            new[] { -275, -225, -175 }.ToList().ForEach(y =>
            {
                var i = (y + 275) / 50;

                var elem = HudElem.NewClientHudElem(player);
                elem.X = 40;
                elem.Y = y;
                elem.AlignX = "right";
                elem.AlignY = "bottom";
                elem.HorzAlign = "right";
                elem.VertAlign = "bottom";
                elem.FontScale = 1.5f;
                elem.SetText("Quickdraw");
                elem.Alpha = 0;
                elem.HideWhenInMenu = true;
                elem.Foreground = true;

                names[i] = elem;
            });

            player.SetField("shrp_perkNames", new Parameter(names));
        }
Example #32
0
        private void CreateHUD(Entity player)
        {
            if (player.HasField("bohud_created"))
            {
                return;
            }

            // background bars, left side
            var bars = new HudElem[2];

            new[] { new { X = -20, Y = 15, i = 0 }, new { X = -20, Y = -4, i = 1 } }.ToList().ForEach(coord =>
            {
                var bar = HudElem.NewClientHudElem(player);
                bar.X = coord.X;
                bar.Y = coord.Y;
                bar.AlignX = "left";
                bar.AlignY = "bottom";
                bar.HorzAlign = "left";
                bar.VertAlign = "bottom";
                bar.SetShader("white", 190, 15);
                bar.Alpha = 0.3f;
                bar.HideWhenInMenu = true;
                bar.Foreground = false;

                bars[coord.i] = bar;
            });

            player.SetField("bohud_bars", new Parameter(bars));

            // ranking background
            var circle = HudElem.CreateIcon(player, "cardicon_radiation", 60, 60);
            circle.SetPoint("bottom left", "bottom left", 15, -15);
            circle.HideWhenInMenu = true;
            circle.Foreground = true;
            circle.Alpha = 1;

            player.SetField("bohud_circle", new Parameter(circle));

            // rank text/shadow
            var rankX = -26;
            player.SetField("bohud_rankX", rankX);

            var rankText = new HudElem[3];

            new[] {
                new { X = rankX - 1, Sort = 3 },
                new { X = rankX + 1, Sort = 4 },
                new { X = rankX, Sort = 5 }
            }.ToList().ForEach(entry =>
            {
                var text = HudElem.NewClientHudElem(player);
                text.X = entry.X;
                text.Y = 18;
                text.AlignX = "left";
                text.AlignY = "bottom";
                text.HorzAlign = "left";
                text.VertAlign = "bottom";
                text.FontScale = 5;
                text.Sort = entry.Sort;
                text.HideWhenInMenu = true;
                text.SetText((entry.Sort == 5) ? "1" : "^01");

                rankText[entry.Sort - 3] = text;
            });

            player.SetField("bohud_rankText", new Parameter(rankText));

            // message texts
            var messageText = new HudElem[2];

            new[] {
                new { X = 30, Y = 16, Text = "", i = 0 },
                new { X = 30, Y = -3, Text = "0", i = 1 },
            }.ToList().ForEach(entry =>
            {
                var text = HudElem.NewClientHudElem(player);
                text.X = entry.X;
                text.Y = entry.Y;
                text.AlignX = "left";
                text.AlignY = "bottom";
                text.HorzAlign = "left";
                text.VertAlign = "bottom";
                text.FontScale = 1.5f;
                text.Alpha = 0.5f;
                text.HideWhenInMenu = true;
                text.Sort = 5;
                text.SetText(entry.Text);

                messageText[entry.i] = text;
            });

            player.SetField("bohud_messageText", new Parameter(messageText));

            // ammo stuff
            var ammoSlash = HudElem.CreateFontString(player, "default", 1.25f);
            ammoSlash.SetPoint("bottom right", "bottom right", -85, -35);
            ammoSlash.GlowAlpha = 0;
            ammoSlash.HideWhenInMenu = true;
            ammoSlash.Archived = false;
            ammoSlash.SetText("/");

            player.SetField("bohud_ammoSlash", new Parameter(ammoSlash));

            var ammoStock = HudElem.CreateFontString(player, "default", 1.25f);
            ammoStock.Parent = ammoSlash;
            ammoStock.SetPoint("bottom left", "bottom left", 3, 0);
            ammoStock.GlowAlpha = 0;
            ammoStock.HideWhenInMenu = true;
            ammoStock.Archived = false;
            ammoStock.SetText("48");

            player.SetField("bohud_ammoStock", new Parameter(ammoStock));

            var ammoClip = HudElem.CreateFontString(player, "default", 1.95f);
            ammoClip.Parent = ammoSlash;
            ammoClip.SetPoint("right", "right", -7, -4);
            ammoClip.GlowAlpha = 0;
            ammoClip.HideWhenInMenu = true;
            ammoClip.Archived = false;
            ammoClip.SetText("12");

            player.SetField("bohud_ammoClip", new Parameter(ammoClip));

            player.SetField("bohud_created", true);
        }