Exemple #1
0
        public static void AutohausSetzen(Vehicle Auto, int Autohaus)
        {
            String VerkaufsText = null;

            foreach (AutoLokal auto in Funktionen.AutoListe)
            {
                if (Auto.GetData("Id") == auto.Id)
                {
                    auto.FahrzeugAutohaus = Autohaus;
                    auto.FahrzeugGeändert = true;

                    if (Autohaus > 0)
                    {
                        VerkaufsText  = "~r~[~w~Zu verkaufen~r~]~n~";
                        VerkaufsText += "Name~w~: " + auto.FahrzeugName + "~n~~r~";
                        VerkaufsText += "Autohaus~w~: " + Autohaus + "~n~~r~";
                        VerkaufsText += "Preis~w~: " + Funktionen.GeldFormatieren(auto.FahrzeugKaufpreis);
                    }
                    else if (Autohaus < 0)
                    {
                        VerkaufsText  = "~r~[~w~Manufaktur~r~]~n~";
                        VerkaufsText += "Name~w~: " + auto.FahrzeugName + "~n~~r~";
                        VerkaufsText += "Preis~w~: " + Funktionen.GeldFormatieren(auto.FahrzeugKaufpreis);
                    }

                    auto.AutohausTextLabel = NAPI.TextLabel.CreateTextLabel(VerkaufsText, new Vector3(Auto.Position.X, Auto.Position.Y, Auto.Position.Z), 18.0f, 1.00f, 4, new Color(255, 255, 255), false, 0);
                }
            }
        }
Exemple #2
0
        public void GeburtstagVersuch(Client Player, String geburtstag)
        {
            DateTime Geburtstag = DateTime.Parse(geburtstag);

            if (Geburtstag > DateTime.Now)
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Der Geburtstag muss in der Vergangenheit liegen."); return;
            }
            if (Geburtstag < DateTime.Parse("01/01/1950"))
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: So alt kannst du nicht sein!"); return;
            }
            if (Geburtstag > DateTime.Today.AddYears(-18))
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Du musst mindestens 18 Jahre alt sein!"); return;
            }

            var Account = ContextFactory.Instance.srp_accounts.Where(x => x.SocialClub == Player.SocialClubName).FirstOrDefault();

            Account.GeburtsDatum = Geburtstag;

            Player.TriggerEvent("kameraoff");
            Player.TriggerEvent("geburtstagbrowserschliessen");

            Funktionen.SpielerLaden(Player);
            Funktionen.SpawnManager(Player);
            Funktionen.LogEintrag(Player, "Geburtstag gesetzt: " + Geburtstag);

            ContextFactory.Instance.SaveChanges();
        }
Exemple #3
0
        public static void FahrzeugKaufenAutohaus(Client Player, Vehicle Auto)
        {
            //Benötigte Definitionen
            String VerkaufsText = null;
            double Rechnen      = 0.0;

            foreach (AutoLokal auto in Funktionen.AutoListe)
            {
                if (Auto.GetData("Id") == auto.Id)
                {
                    auto.FahrzeugAutohaus = Funktionen.AccountAutohausBekommen(Player);
                    auto.AutohausTextLabel.Delete();

                    Rechnen = auto.FahrzeugKaufpreis + auto.FahrzeugKaufpreis * 0.2;
                    auto.FahrzeugKaufpreis    = (long)Rechnen;
                    auto.FahrzeugBeschreibung = "Autohaus";

                    VerkaufsText  = "~r~[~w~Zu verkaufen~r~]~n~";
                    VerkaufsText += "Name~w~: " + auto.FahrzeugName + "~n~~r~";
                    VerkaufsText += "Autohaus~w~: " + auto.FahrzeugAutohaus + "~n~~r~";
                    VerkaufsText += "Preis:~w~ " + Funktionen.GeldFormatieren(auto.FahrzeugKaufpreis);

                    auto.AutohausTextLabel = NAPI.TextLabel.CreateTextLabel(VerkaufsText, new Vector3(auto.FahrzeugX, auto.FahrzeugY, auto.FahrzeugZ), 18.0f, 1.00f, 4, new Color(255, 255, 255), false, 0);

                    auto.FahrzeugGeändert = true;
                }
            }
        }
Exemple #4
0
        public void NicknameVersuch(Client Player, String nickname)
        {
            var Check = ContextFactory.Instance.srp_accounts.Count(x => x.NickName == nickname);
            {
                //Prüfen ob der Nickname bereits vorhanden ist
                if (Check > 0)
                {
                    NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Der Name" + nickname + " wird bereits bei uns verwendet!");
                }
                else
                {
                    if (nickname.Length < 4)
                    {
                        NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Der Nickname sollte mindestens 4 Zeichen haben!"); return;
                    }
                    if (nickname.Contains(" "))
                    {
                        NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Dieser Nickname ist nicht möglich!"); return;
                    }

                    var Account = ContextFactory.Instance.srp_accounts.Where(x => x.SocialClub == Player.SocialClubName).FirstOrDefault();
                    Account.NickName = nickname;

                    NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: ~w~Du heißt jetzt " + nickname + "!");

                    Player.TriggerEvent("nicknamebrowserschliessen");
                    Player.TriggerEvent("geburtstagbrowseroeffnen");

                    Funktionen.LogEintrag(Player, "Nickname gesetzt: " + nickname);

                    ContextFactory.Instance.SaveChanges();
                }
            }
        }
Exemple #5
0
        public void OnPlayerConnected(Client Player)
        {
            //Eingeloggt auf 0 für Command Check
            Player.SetData("Eingeloggt", 0);
            Player.SetData("HatAccount", 0);

            //Chat weg
            Player.TriggerEvent("Chathiden");
            Player.SetData("Chat", 0);

            //Whitelist Check
            var Check = ContextFactory.Instance.srp_whitelist.Count(x => x.SocialClub == Player.SocialClubName);

            {
                if (Check == 0)
                {
                    NAPI.Notification.SendNotificationToPlayer(Player, "~r~Du bist nicht auf der Whitelist. Melde dich auf www.strawberry-rp.de");

                    //Log Eintrag
                    Funktionen.LogEintrag(Player, "Nicht auf der Whitelist");

                    NAPI.Player.KickPlayer(Player, "Nicht auf der Whitelist");
                    return;
                }
            }

            //DLCs Checken
            Player.TriggerEvent("checkDLC");

            //Log Eintrag
            Funktionen.LogEintrag(Player, "Verbunden");

            //Consolen Nachricht
            NAPI.Util.ConsoleOutput("[StrawberryRP] " + Player.SocialClubName + " hat sich mit dem Server verbunden. [" + DateTime.Now + "]", ConsoleColor.Red);

            //Laden und danach Login/Register
            Player.TriggerEvent("Laden");
            Timer.SetTimer(() => Funktionen.LoginLadenBeenden(Player), 4000, 1);

            //An den eine Versteckte Position setzen damit er nirgendwo rumsteht
            Player.Position = new Vector3(-3245.781, 945.7014, 7.519356);

            //Freeze
            Funktionen.Freeze(Player);

            //Camera
            Player.TriggerEvent("moveSkyCamera", Player, "up", 1, false);
        }
Exemple #6
0
        public void OnPlayerExitVehicle(Client Player, Vehicle vehicle)
        {
            AutoLokal auto = new AutoLokal();

            auto = Funktionen.AutoBekommen(Player.Vehicle);

            if (auto.FahrzeugJob == 1 && vehicle.GetData("GeradeGespawnt") == 0)
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Fertig mit jobben? /beenden");
            }
            else
            {
                Funktionen.FahrzeugSpeichern(vehicle);
                Funktionen.FahrzeugMotor(vehicle);
            }
        }
Exemple #7
0
        public void RollerMieten(Client Player)
        {
            //Das Fahrzeug greifen
            AutoLokal auto = new AutoLokal();

            auto = Funktionen.AutoBekommen(Player.Vehicle);

            if (Funktionen.AccountGeldBekommen(Player) < auto.FahrzeugMietpreis)
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Du hast nicht genug Geld.");
                Player.TriggerEvent("rollermietenpopupschliessen");
            }
            else
            {
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Du hast das Fahrzeug gemietet.");
                Funktionen.AccountGeldSetzen(Player, 2, auto.FahrzeugMietpreis);
                Player.TriggerEvent("rollermietenpopupschliessen");
            }
        }
    void checkFunctionality()
    {
        if (functionality != oldFunctionality)
        {
            if (oldFunctionality != Funktionen.none)
            {
                removeOldFunctionality();
                oldFunctionality = functionality;
            }

            switch (functionality)
            {
                case Funktionen.loadLevel:
                    {
                        b.onClick.AddListener(startLevelAction);
                    } break;
                case Funktionen.setlevel:
                    {
                        b.onClick.AddListener(setLevelAction);
                    } break;
                case Funktionen.pauseLevel:
                    {
                        b.onClick.AddListener(pauseLevel);
                    } break;
                case Funktionen.unpauseLevel:
                    {
                        b.onClick.AddListener(resumeLevel);
                    } break;
                case Funktionen.quitToMainMenu:
                    {
                        b.onClick.AddListener(loadMainMenu);
                    } break;
                case Funktionen.quitGame:
                    {
                        b.onClick.AddListener(quitGame);
                    } break;
            }

        }
    }
Exemple #9
0
        public void LoginVersuch(Client player, string passwort)
        {
            var Check = ContextFactory.Instance.srp_accounts.Count(x => x.SocialClub == player.SocialClubName);

            if (Check == 0)
            {
                NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: Der Name " + player.SocialClubName + " ist noch nicht bei uns registriert!");
            }
            else
            {
                foreach (var Account in ContextFactory.Instance.srp_accounts.Where(x => x.SocialClub == player.SocialClubName).ToList())
                {
                    if (GetMD5Hash(passwort) == Account.Passwort)
                    {
                        player.TriggerEvent("browserschliessen");

                        Funktionen.LogEintrag(player, "Eingeloggt");
                        if (Account.NickName == "Keiner")
                        {
                            player.TriggerEvent("nicknamebrowseroeffnen");
                        }
                        else if (Account.GeburtsDatum == DateTime.Parse("01/01/1900"))
                        {
                            player.TriggerEvent("geburtstagbrowseroeffnen");
                        }
                        else
                        {
                            Funktionen.SpielerLaden(player);
                            Funktionen.SpawnManager(player);
                            player.TriggerEvent("kameraoff");
                        }
                    }
                    else
                    {
                        NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: ~w~Dieses Passwort scheint nicht zu stimmen!");
                    }
                }
            }
        }
        public void Benützen()
        {
            FunktionenAnzeigen();

            while (true)
            {
                char taste = Console.ReadKey().KeyChar;
                Console.WriteLine();

                if (!Funktionen.ContainsKey(taste))
                {
                    continue;
                }

                Action f = Funktionen[taste];

                switch (taste)
                {
                case '1': f = TV.Einschalten; break;

                case '+': f = TV.Lauterdrehen; break;

                case '-': f = TV.Leiserdrehen; break;

                case 'n': f = TV.NächsterSender; break;

                case 'v': f = TV.VorherigerSender; break;

                case 'x': f = TV.Ausschalten; break;

                default: continue;
                }

                f?.Invoke();

                Console.WriteLine(TV);
            }
        }
Exemple #11
0
        public void OnPlayerDisconnected(Client Player, DisconnectionType type, string reason)
        {
            //Nur speichern wenn er Eingeloggt war
            if (Player.GetData("Eingeloggt") == 1)
            {
                Fahrzeuge.JobFahrzeugLöschen(Player, Funktionen.AccountJobFahrzeugBekommen(Player));
                Funktionen.AccountPositionInteriorDimensionUpdaten(Player);
                Funktionen.SpielerSpeichernDisconnect(Player);

                //Spieler Online Status
                Funktionen.ServerSpielerGejoined(2);
            }

            //Daten zur Sicherheit zurücksetzen
            //Generelle Daten
            Player.SetData("HatAccount", 0);
            Player.SetData("InteriorName", 0);
            Player.SetData("Eingeloggt", 1);
            Player.SetData("BewegtSichMitFahrzeug", 0);
            Player.SetData("SiehtPerso", 0);
            Player.SetData("IBerry", 0);
            Player.SetData("Scoreboard", 0);
            Player.SetData("Interaktionsmenu", 0);
            Player.SetData("Freezed", 0);
            Player.SetData("AmTanken", 0);
            Player.SetData("TankenTankstellenId", 0);
            Player.SetData("TankRechnung", 0);
            Player.SetData("KaufenTyp", 0);
            Player.SetData("KaufenId", 0);
            Player.SetData("KaufenPreis", 0);
            Player.SetData("KeyCoolDown", 0);
            Player.SetData("MenuCoolDown", 0);
            Player.SetData("Verwaltungsmodus", 0);
            Player.SetData("NachträglicherNickname", 0);
            Player.SetData("HeiratsAntrag", 0);
            Player.SetData("HeiratsId", 0);
            Player.SetData("HeiratenId", 0);
            Player.SetData("HeiratenBrowser", 0);
            Player.SetData("GruppenEinladungId", 0);
            Player.SetData("StadthalleInt", 0);
            Player.SetData("Chat", 0);

            //Job Daten Berufskraftfahrer
            Player.SetData("BerufskraftfahrerFahrzeug", 0);
            Player.SetData("BerufskraftfahrerHolz", 0);
            Player.SetData("BerufskraftfahrerHolzGeladen", 0);
            Player.SetData("BerufskraftfahrerJobAngenommen", 0);
            Player.SetData("BerufskraftfahrerKraftstoffTyp", 0);
            Player.SetData("BerufskraftfahrerDieselTanke", 0);
            Player.SetData("BerufskraftfahrerE10Tanke", 0);
            Player.SetData("BerufskraftfahrerSuperTanke", 0);
            Player.SetData("BerufskraftfahrerVerdienst", 0);
            Player.SetData("BerufskraftfahrerAmAbladen", 0);

            //Job Daten Busfahrer
            Player.SetData("BusfahrerFahrzeug", 0);
            Player.SetData("BusfahrerJobAngenommen", 0);
            Player.SetData("BusfahrerRoute", 0);
            Player.SetData("BusfahrerRoutePosition", 0);

            //Dialoge
            Player.SetData("FahrzeugPrivatDialog", 0);

            //Voice
            Player.SetData("IS_SPEAKING", 0);

            //Voice Disconnect
            Player.TriggerEvent("DisconnectTeamspeak");

            Funktionen.LogEintrag(Player, "Verbindung getrennt");
            NAPI.Util.ConsoleOutput("[StrawberryRP] " + Player.SocialClubName + " hat den Server verlassen.", ConsoleColor.Red);
        }
Exemple #12
0
        public static List <AutoLokal> AlleAutosLadenDB()
        {
            List <AutoLokal> AutoListe = new List <AutoLokal>();

            foreach (var Fahrzeuge in ContextFactory.Instance.srp_fahrzeuge.Where(x => x.Id > 0).ToList())
            {
                AutoLokal auto = new AutoLokal();

                //Definitionen
                uint   AutoCode     = NAPI.Util.GetHashKey(Fahrzeuge.FahrzeugName);
                String VerkaufsText = null;

                //Die eigentliche Erstellung des Fahrzeuges
                auto.Fahrzeug = NAPI.Vehicle.CreateVehicle(AutoCode, new Vector3(Fahrzeuge.FahrzeugX, Fahrzeuge.FahrzeugY, Fahrzeuge.FahrzeugZ), Fahrzeuge.FahrzeugRot, Fahrzeuge.FahrzeugFarbe1, Fahrzeuge.FahrzeugFarbe2);

                //ID Lokal setzen damit man das Fahrzeug erkennen kann
                auto.Fahrzeug.SetData("Id", Fahrzeuge.Id);

                auto.Fahrzeug.Dimension = 0;

                auto.Id = Fahrzeuge.Id;
                auto.FahrzeugBeschreibung  = Fahrzeuge.FahrzeugBeschreibung;
                auto.FahrzeugName          = Fahrzeuge.FahrzeugName;
                auto.FahrzeugTyp           = Fahrzeuge.FahrzeugTyp;
                auto.FahrzeugFraktion      = Fahrzeuge.FahrzeugFraktion;
                auto.FahrzeugJob           = Fahrzeuge.FahrzeugJob;
                auto.FahrzeugSpieler       = Fahrzeuge.FahrzeugSpieler;
                auto.FahrzeugMietpreis     = Fahrzeuge.FahrzeugMietpreis;
                auto.FahrzeugKaufpreis     = Fahrzeuge.FahrzeugKaufpreis;
                auto.FahrzeugAutohaus      = Fahrzeuge.FahrzeugAutohaus;
                auto.FahrzeugMaxMietzeit   = Fahrzeuge.FahrzeugMaxMietzeit;
                auto.FahrzeugMietzeit      = Fahrzeuge.FahrzeugMietzeit;
                auto.FahrzeugX             = Fahrzeuge.FahrzeugX;
                auto.FahrzeugY             = Fahrzeuge.FahrzeugY;
                auto.FahrzeugZ             = Fahrzeuge.FahrzeugZ;
                auto.FahrzeugRot           = Fahrzeuge.FahrzeugRot;
                auto.FahrzeugFarbe1        = Fahrzeuge.FahrzeugFarbe1;
                auto.FahrzeugFarbe2        = Fahrzeuge.FahrzeugFarbe2;
                auto.TankVolumen           = Fahrzeuge.TankVolumen;
                auto.TankInhalt            = Fahrzeuge.TankInhalt * 10 * 100;
                auto.Kilometerstand        = Fahrzeuge.Kilometerstand * 10 * 100;
                auto.KraftstoffArt         = Fahrzeuge.KraftstoffArt;
                auto.FahrzeugHU            = Fahrzeuge.FahrzeugHU;
                auto.FahrzeugAbgeschlossen = Fahrzeuge.FahrzeugAbgeschlossen;
                auto.FahrzeugMotor         = Fahrzeuge.FahrzeugMotor;

                //Nur lokal
                auto.FahrzeugAltePositionX = Fahrzeuge.FahrzeugX;
                auto.FahrzeugAltePositionY = Fahrzeuge.FahrzeugY;
                auto.FahrzeugAltePositionZ = Fahrzeuge.FahrzeugZ;
                auto.FahrzeugNeuePositionX = 0;
                auto.FahrzeugNeuePositionY = 0;
                auto.FahrzeugNeuePositionZ = 0;

                //Zur Liste hinzufügen
                AutoListe.Add(auto);

                //Zuweisungen für das Auto
                auto.Fahrzeug.NumberPlate = Fahrzeuge.FahrzeugBeschreibung;

                if (auto.FahrzeugMotor == 0)
                {
                    auto.Fahrzeug.EngineStatus = false;
                }
                else
                {
                    auto.Fahrzeug.EngineStatus = true;
                }

                //Schauen ob es ein Verkaufs Auto ist
                if (auto.FahrzeugAutohaus > 0)
                {
                    VerkaufsText  = "~r~[~w~Zu verkaufen~r~]~n~";
                    VerkaufsText += "Name~w~: " + auto.FahrzeugName + "~n~~r~";
                    VerkaufsText += "Autohaus~w~: " + auto.FahrzeugAutohaus + "~n~~r~";
                    VerkaufsText += "Preis:~w~ " + Funktionen.GeldFormatieren(auto.FahrzeugKaufpreis);

                    auto.AutohausTextLabel = NAPI.TextLabel.CreateTextLabel(VerkaufsText, new Vector3(Fahrzeuge.FahrzeugX, Fahrzeuge.FahrzeugY, Fahrzeuge.FahrzeugZ), 18.0f, 1.00f, 4, new Color(255, 255, 255), false, 0);
                }
                if (auto.FahrzeugAutohaus < 0)
                {
                    VerkaufsText  = "~r~[~w~Manufaktur~r~]~n~";
                    VerkaufsText += "Name~w~: " + auto.FahrzeugName + "~n~~r~";
                    VerkaufsText += "Preis:~w~ " + Funktionen.GeldFormatieren(auto.FahrzeugKaufpreis);

                    auto.AutohausTextLabel = NAPI.TextLabel.CreateTextLabel(VerkaufsText, new Vector3(Fahrzeuge.FahrzeugX, Fahrzeuge.FahrzeugY, Fahrzeuge.FahrzeugZ), 18.0f, 1.00f, 4, new Color(255, 255, 255), false, 0);
                }
            }
            return(AutoListe);
        }
Exemple #13
0
 public void OnResourceStart()
 {
     Funktionen.AllesStarten();
     NAPI.Server.SetAutoSpawnOnConnect(false);
 }
Exemple #14
0
        public void RegistrierenVersuch(Client player, string passwort)
        {
            var Check = ContextFactory.Instance.srp_accounts.Count(x => x.SocialClub == player.SocialClubName);
            {
                //Prüfen ob der Social Club Name bereits registriert ist
                if (Check > 0)
                {
                    NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: Der Name " + player.SocialClubName + " ist bereits bei uns registriert!");
                }
                else
                {
                    //Passwortlänge prüfen
                    if (passwort.Length < 6)
                    {
                        NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: Das Passwort sollte minimum 6 Zeichen haben!"); return;
                    }
                    if (passwort.Contains(" "))
                    {
                        NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: Leerzeichen sind ungültig!"); return;
                    }

                    var NeuerAccount = new Account
                    {
                        SocialClub           = player.SocialClubName,
                        NickName             = "Keiner",
                        Passwort             = GetMD5Hash(passwort),
                        AdminLevel           = 0,
                        Fraktion             = 0,
                        FraktionRang         = 0,
                        Job                  = 0,
                        Geld                 = GlobaleSachen.StartGeld,
                        BankGeld             = 0,
                        Perso                = 0,
                        Spielzeit            = 0,
                        Exp                  = 0,
                        Gruppe               = 0,
                        GeburtsDatum         = DateTime.Parse("01/01/1900"),
                        EinreiseDatum        = DateTime.Now,
                        ZuletztOnline        = DateTime.Now,
                        Verheiratet          = "Nein",
                        FahrzeugSchlüssel    = 0,
                        Kündigungszeit       = 0,
                        PositionX            = -3260.276f,
                        PositionY            = 967.3442f,
                        PositionZ            = 8.832886f,
                        PositionRot          = 270.343f,
                        Dimension            = 0,
                        Interior             = "0",
                        Component1Drawable   = 0,
                        Component3Drawable   = 0,
                        Component4Drawable   = 0,
                        Component6Drawable   = 0,
                        Component7Drawable   = 0,
                        Component8Drawable   = 0,
                        Component11Drawable  = 0,
                        BerufskraftfahrerExp = 0,
                        Tutorial             = 0
                    };

                    //Query absenden
                    ContextFactory.Instance.srp_accounts.Add(NeuerAccount);
                    ContextFactory.Instance.SaveChanges();

                    Funktionen.LogEintrag(player, "Registriert");

                    player.TriggerEvent("browserschliessen");
                    player.TriggerEvent("nicknamebrowseroeffnen");

                    NAPI.Notification.SendNotificationToPlayer(player, "~y~Info~w~: Du hast dich erfolgreich als " + player.SocialClubName + " registriert!");
                }
            }
        }
Exemple #15
0
        public void OnPlayerEnterVehicle(Client Player, Vehicle vehicle, sbyte seatID)
        {
            //Abfragen damit niemand mit den autos rumfahren kann
            if (Player.GetData("VerwaltungsModus") == 0)
            {
                if (AutoHausBekommen(Player.Vehicle) == -1 && Funktionen.AccountHatAutohaus(Player) == 0)
                {
                    Player.TriggerEvent("FahrzeugVerlassen"); return;
                }
            }

            //Mietfahrzeug
            if (TypBekommen(Player.Vehicle) == 2)
            {
                if (NameBekommen(Player.Vehicle) == "faggio")
                {
                    Player.TriggerEvent("RollerSpeed");
                }
                else if (NameBekommen(Player.Vehicle) == "pounder2")
                {
                    Player.TriggerEvent("LKWSpeed");
                }

                if (Player.GetData("VerwaltungsModus") == 0)
                {
                    if (BeschreibungBekommen(Player.Vehicle) != "Nicos Auto")
                    {
                        Player.TriggerEvent("rollermietenpopupoeffnen", Funktionen.GeldFormatieren(MietpreisBekommen(Player.Vehicle)));
                    }
                }
            }
            //Autohausfahrzeug
            else if (TypBekommen(Player.Vehicle) == 5 && AutoHausBekommen(Player.Vehicle) > 0)
            {
                if (Player.GetData("VerwaltungsModus") == 0)
                {
                    if (Player.GetData("KaufenTyp") == 5)
                    {
                        NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Schließe erst das aktuelle Fenster."); return;
                    }
                    Player.SetData("KaufenTyp", 5);
                    Player.SetData("KaufenId", IdBekommen(Player.Vehicle));
                    Player.SetData("KaufenPreis", KaufPreisBekommen(Player.Vehicle));

                    //Freezen
                    Funktionen.Freeze(Player);

                    Player.TriggerEvent("Kaufen", 5, Funktionen.GeldFormatieren(KaufPreisBekommen(Player.Vehicle)));
                }
            }
            //Manufaktur Fahrzeuge
            else if (AutoHausBekommen(Player.Vehicle) == -1 && Funktionen.AccountHatAutohaus(Player) == 1)
            {
                if (Player.GetData("VerwaltungsModus") == 0)
                {
                    if (Player.GetData("KaufenTyp") == 6)
                    {
                        NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Schließe erst das aktuelle Fenster."); return;
                    }
                    Player.SetData("KaufenTyp", 6);
                    Player.SetData("KaufenId", IdBekommen(Player.Vehicle));
                    Player.SetData("KaufenPreis", KaufPreisBekommen(Player.Vehicle));

                    //Benötigte Definitionen
                    double Rechnen  = 0.0;
                    long   Rechnen1 = 0;
                    Rechnen  = KaufPreisBekommen(Player.Vehicle) + KaufPreisBekommen(Player.Vehicle) * 0.2;
                    Rechnen1 = (long)Rechnen;

                    //Freezen
                    Funktionen.Freeze(Player);

                    Player.TriggerEvent("Kaufen", 6, Funktionen.GeldFormatieren(KaufPreisBekommen(Player.Vehicle)), Funktionen.GeldFormatieren(Rechnen1));
                }
            }
        }
Exemple #16
0
        public static void HelmutFahrzeugErstellen(Client Player)
        {
            //Definitionen
            uint AutoCode = NAPI.Util.GetHashKey("mk7");

            RandomSpawns rs = new RandomSpawns();

            rs = Funktionen.RandomSpawnObjektBekommen(Funktionen.RandomSpawnBekommen("Helmut"));

            //Ein neues Objekt erzeugen
            var veh = new Auto
            {
                FahrzeugBeschreibung  = "Nicos Auto",
                FahrzeugName          = Funktionen.ErsterBuchstabeGroß("mk7"),
                FahrzeugTyp           = 2,
                FahrzeugFraktion      = 0,
                FahrzeugJob           = 0,
                FahrzeugSpieler       = Player.GetData("Id"),
                FahrzeugMietpreis     = 0,
                FahrzeugKaufpreis     = 0,
                FahrzeugAutohaus      = 0,
                FahrzeugMaxMietzeit   = 120,
                FahrzeugMietzeit      = 0,
                FahrzeugX             = rs.PosX,
                FahrzeugY             = rs.PosY,
                FahrzeugZ             = rs.PosZ,
                FahrzeugRot           = rs.RotZ,
                FahrzeugFarbe1        = 0,
                FahrzeugFarbe2        = 0,
                TankVolumen           = Funktionen.TankVolumenBerechnen("mk7"),
                TankInhalt            = Funktionen.TankVolumenBerechnen("mk7") * 10 * 100,
                Kilometerstand        = 0.0f,
                KraftstoffArt         = 3,
                FahrzeugHU            = DateTime.Now.AddMonths(+1),
                FahrzeugAbgeschlossen = 0,
                FahrzeugMotor         = 1,
                FahrzeugGespawnt      = 1
            };

            //Query absenden
            ContextFactory.Instance.srp_fahrzeuge.Add(veh);
            ContextFactory.Instance.SaveChanges();


            //Objekt für die Liste erzeugen
            AutoLokal auto = new AutoLokal();

            //Das Fahrzeug spawnen
            auto.Fahrzeug = NAPI.Vehicle.CreateVehicle(AutoCode, new Vector3(rs.PosX, rs.PosY, rs.PosZ), rs.RotZ, 0, 0, numberPlate: "Nico");

            auto.Fahrzeug.NumberPlate = "Nico";
            auto.Fahrzeug.Dimension   = 0;

            //Dem Fahrzeug die Werte lokal übergeben
            auto.Id = ContextFactory.Instance.srp_fahrzeuge.Max(x => x.Id);
            auto.FahrzeugBeschreibung  = "Nicos Auto";
            auto.FahrzeugName          = Funktionen.ErsterBuchstabeGroß("mk7");
            auto.FahrzeugTyp           = 2;
            auto.FahrzeugFraktion      = 0;
            auto.FahrzeugJob           = 0;
            auto.FahrzeugSpieler       = Player.GetData("Id");
            auto.FahrzeugMietpreis     = 0;
            auto.FahrzeugKaufpreis     = 0;
            auto.FahrzeugAutohaus      = 0;
            auto.FahrzeugMaxMietzeit   = 120;
            auto.FahrzeugMietzeit      = 0;
            auto.FahrzeugX             = rs.PosX;
            auto.FahrzeugY             = rs.PosY;
            auto.FahrzeugZ             = rs.PosZ;
            auto.FahrzeugRot           = rs.RotZ;
            auto.FahrzeugFarbe1        = 0;
            auto.FahrzeugFarbe2        = 0;
            auto.TankVolumen           = Funktionen.TankVolumenBerechnen("Golf");
            auto.TankInhalt            = Funktionen.TankVolumenBerechnen("Golf") * 10 * 100;
            auto.Kilometerstand        = 0;
            auto.KraftstoffArt         = 3;
            auto.FahrzeugHU            = DateTime.Now.AddMonths(+1);
            auto.FahrzeugAbgeschlossen = 0;
            auto.FahrzeugMotor         = 1;
            auto.FahrzeugGespawnt      = 1;

            //Diese Sachen nur lokal
            auto.FahrzeugAltePositionX = rs.PosX;
            auto.FahrzeugAltePositionY = rs.PosY;
            auto.FahrzeugAltePositionZ = rs.PosZ;
            auto.FahrzeugNeuePositionX = 0;
            auto.FahrzeugNeuePositionY = 0;
            auto.FahrzeugNeuePositionZ = 0;

            //Fahrzeug in der Liste ablegen
            Funktionen.AutoListe.Add(auto);

            //Dem Auto die DB Id lokal geben
            auto.Fahrzeug.SetData("Id", ContextFactory.Instance.srp_fahrzeuge.Max(x => x.Id));
            auto.Fahrzeug.EngineStatus = true;

            NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Das Auto von Helmuts Enkel steht gleich hier auf dem Parkplatz.");
            NAPI.Notification.SendNotificationToPlayer(Player, "~y~Nachricht~w~: GPS Coordinaten von Helmut.");
            var MannImBlumenFeld = new Vector3(1331.05, -2458.33, 0);

            Player.TriggerEvent("Navigation", MannImBlumenFeld.X, MannImBlumenFeld.Y);
        }
Exemple #17
0
        public static void JobFahrzeugLöschen(Client Player, Vehicle Fahrzeug)
        {
            if (Funktionen.AccountJobFahrzeugBekommen(Player) != null)
            {
                if (Player.GetData("BerufskraftfahrerDieselTanke") != 0 || Player.GetData("BerufskraftfahrerE10Tanke") != 0 || Player.GetData("BerufskraftfahrerSuperTanke") != 0)
                {
                    if (Player.GetData("BerufskraftfahrerDieselTanke") != 0)
                    {
                        foreach (TankstelleLokal tanke in Funktionen.TankenListe)
                        {
                            if (tanke.Id == Player.GetData("BerufskraftfahrerDieselTanke"))
                            {
                                tanke.TankstelleJobSpieler = 0;
                            }
                        }
                    }
                    else if (Player.GetData("BerufskraftfahrerE10Tanke") != 0)
                    {
                        foreach (TankstelleLokal tanke in Funktionen.TankenListe)
                        {
                            if (tanke.Id == Player.GetData("BerufskraftfahrerE10Tanke"))
                            {
                                tanke.TankstelleJobSpieler = 0;
                            }
                        }
                    }
                    else if (Player.GetData("BerufskraftfahrerSuperTanke") != 0)
                    {
                        foreach (TankstelleLokal tanke in Funktionen.TankenListe)
                        {
                            if (tanke.Id == Player.GetData("BerufskraftfahrerSuperTanke"))
                            {
                                tanke.TankstelleJobSpieler = 0;
                            }
                        }
                    }
                }

                AutoLokal auto = new AutoLokal();
                auto = Funktionen.AutoBekommen(Fahrzeug);
                NAPI.Notification.SendNotificationToPlayer(Player, "~y~Info~w~: Dein Job wurde beendet.");
                //Berufskraftfahrer
                Player.SetData("BerufskraftfahrerFahrzeug", 0);
                Player.SetData("BerufskraftfahrerHolz", 0);
                Player.SetData("BerufskraftfahrerHolzGeladen", 0);
                Player.SetData("BerufskraftfahrerJobAngenommen", 0);
                Player.SetData("BerufskraftfahrerKraftstoffTyp", 0);
                Player.SetData("BerufskraftfahrerDieselTanke", 0);
                Player.SetData("BerufskraftfahrerE10Tanke", 0);
                Player.SetData("BerufskraftfahrerSuperTanke", 0);
                Player.SetData("BerufskraftfahrerVerdienst", 0);
                Player.SetData("BerufskraftfahrerAmAbladen", 0);

                //Busfahrer
                Player.SetData("BusfahrerFahrzeug", 0);
                Player.SetData("BusfahrerJobAngenommen", 0);
                Player.SetData("BusfahrerRoute", 0);
                Player.SetData("BusfahrerRoutePosition", 0);

                auto.Fahrzeug.Delete();

                Funktionen.AutoListe.Remove(auto);

                Funktionen.AccountJobFahrzeugSetzen(Player, null);

                //Navi resetten
                var EigenerPunkt = new Vector3(Player.Position.X, Player.Position.Y, 0);
                Player.TriggerEvent("Navigation", EigenerPunkt.X, EigenerPunkt.Y);
            }
        }
Exemple #18
0
        public static void TachoUpdaten()
        {
            //Schleife für alle Autos
            foreach (var Player in NAPI.Pools.GetAllPlayers())
            {
                //Abfrage ob eingeloggt und im Auto und auf dem Fahrersitz ist
                if (Player.IsInVehicle && Player.GetData("Eingeloggt") == 1 && NAPI.Player.GetPlayerVehicleSeat(Player) == -1 && Player.Vehicle.EngineStatus == true)
                {
                    //Benötigte Definitionen
                    float Distanz = 0.0f;
                    float nX, nY, nZ, aX, aY, aZ;

                    //Fahrzeug abprüfen
                    AutoLokal auto = new AutoLokal();
                    auto = Funktionen.AutoBekommen(Player.Vehicle);

                    if (auto.TankInhalt <= 0)
                    {
                        Player.Vehicle.EngineStatus = false;
                        FahrzeugMotor(Player.Vehicle, 0);
                        if (auto.TankInhalt < 0)
                        {
                            auto.TankInhalt = 0.0f;
                        }
                        return;
                    }

                    //Fahrzeug Position zuweisen
                    auto.FahrzeugNeuePositionX = Player.Vehicle.Position.X;
                    auto.FahrzeugNeuePositionY = Player.Vehicle.Position.Y;
                    auto.FahrzeugNeuePositionZ = Player.Vehicle.Position.Z;

                    //Neue Koordinaten an die Variablen geben
                    nX = Player.Vehicle.Position.X;
                    nY = Player.Vehicle.Position.Y;
                    nZ = Player.Vehicle.Position.Z;

                    //Alte Koordinaten an die Variablen geben
                    aX = auto.FahrzeugAltePositionX;
                    aY = auto.FahrzeugAltePositionY;
                    aZ = auto.FahrzeugAltePositionZ;

                    //Distanz mit der Vector3 Distance Funktion errechnen
                    Distanz = Vector3.Distance(new Vector3(nX, nY, nZ), new Vector3(aX, aY, aZ));

                    //Damit wir wissen ob der Spieler steht oder nicht
                    if (Distanz > 2)
                    {
                        Player.SetData("BewegtSichMitFahrzeug", 1);
                    }
                    else
                    {
                        Player.SetData("BewegtSichMitFahrzeug", 0);
                    }

                    //Kilometer und Tank aufsummieren
                    float Kilometer = auto.Kilometerstand + Distanz;

                    //Verbrauch errechnen
                    float Verbraucht = Distanz * GlobaleSachen.Verbrauch;

                    //Wenn er nicht fährt
                    if (Distanz == 0)
                    {
                        Verbraucht = 0.2f;
                    }

                    //Verbrauch subtrahieren
                    float Tank = auto.TankInhalt - Verbraucht;

                    //Dem Fahrzeug den Kilometerstand und Tank setzen
                    auto.Kilometerstand = Kilometer;
                    auto.TankInhalt     = Tank;

                    //Für das Tacho den Kilometerstand runterteilen damit die Zahl lesbar ist
                    float KilometerFloat   = auto.Kilometerstand / 10 / 100;
                    float TankFloat        = auto.TankInhalt / 10 / 100;
                    float TankVolumenFloat = auto.TankVolumen;

                    //Client Event vom Tacho triggern (Tacho/index.js)
                    Player.TriggerEvent("TachoUpdaten", NAPI.Util.ToJson(Math.Round(KilometerFloat, 2)), NAPI.Util.ToJson(Math.Round(TankFloat, 2)), NAPI.Util.ToJson(Math.Round(TankVolumenFloat, 2)));

                    //Vom Fahrzeug die alte Position auf die neue updaten
                    auto.FahrzeugAltePositionX = auto.FahrzeugNeuePositionX;
                    auto.FahrzeugAltePositionY = auto.FahrzeugNeuePositionY;
                    auto.FahrzeugAltePositionZ = auto.FahrzeugNeuePositionZ;

                    auto.FahrzeugGeändert = true;
                }
            }
        }