Beiträge von IDK_WHO_AM_I

Genau was du willst sind Packets die nur ein Spieler sieht! Das ist um einiges mehr Aufwand als ein einfacher NPC, weil du jede Bewegung "manuell" als Packet an den Client senden musst.

Aus Gründen des Aufwandes rate ich hiervon ab. Es ist doch kein Armbruch wenn der NPC nur den Spieler anschaut der sich in der Nähe bewegt

Aber solltest du darauf bestehen wollen. Solltest du dir mal das Grundkonzept von Packets anschauen, wie diese aufgebaut sind und welche es gibt. Mit etwas Recherche sollte das relativ gut machbar sein.

ProtocolLib ist ein guter Anfang, damit hast du das Grundgerüst bereits gegeben. Jetzt müsstest du "nur noch" die Bewegungen selbst programmieren.

Zu Beginn was hast du den schon, wie sieht dein Code bisher aus?

Auch nützlich wären ein paar Informationen zum GUI was soll es können/anzeigen?

Und wenn du deine "Bungeebridge" schon erwähnst sag doch ein paar Worte dazu, was genau die kann?

Zum Konzept:

Ich nehme jetzt einfach mal an du möchtest eine Art Auflistung/Darstellung aller Reports bzw der noch unbearbeiteten Reports und gehe davon aus du kannst OOP und verstehst den Grundaufbau eines solchen Konzeptes.

Vermutlich der beste Weg wäre ein Inventar zu erstellen in dem die unterste Reihe reserviert ist für Navigation. (Erste Seite/Seite zurück/Seite vorwärts/Letzte Seite) um das zu realisieren brauchst du am besten einen Algorithmus der dir eine HashMap mit Seiten und einer Liste der enthaltenen Elemente zurückgibt.

HashMap<Integer, List<Report>>

Die Items solltest du am besten nicht jedesmal in ein neues Inventar legen, sondern ersetzte einfach die bereits vorhandenen.

Alles weitere ist dann nur noch das Darstellen eines Reports bzw. das Ausführen der möglichen Aktionen (Teleport to Suspect/Message Suspect/etc)

Ist das wirklich relevant? was soll überhaupt "Tube" sein? YouTube oder ist das irgendeine "Adult Site"?

Überhaupt ich bin mir sicher dass das rechtlich schwer wird! Denn wie willst du die Webseite testen/prüfen/in Stand halten wenn du die Inhalte rechtlich gesehen nicht mal anschauen dürftest

Naja was er will ist eine Video Streaming Platform mit erweiterbarem/bezahltem Zugang! In etwa wie Amazon Video, Netflix, maxdome. Warum er ein solch bizzares Beispiel dafür nutzt ist mir jedoch auch nicht klar

Also ich würde dir gerne helfen jedoch müssen wir zuerst klären was genau du hier machst den, mir scheint so als hättest du noch nie mit einem Villager gehandelt!

Aber um auf die Frage einzugehen.

Um zu prüfen ob er die "Ware" im Inventar hat das hier: 'Inventory.contains()'

Um die Items dann zu entfernen, gibt es leider seit Anbeginn der Zeit keine vernünftige remove() Methode, weswegen man das kompliziert per Hand machen muss

Deswegen verwenden wir das hier: 'Inventory.all()'

        Inventory inventory = null;
        int productAmount = 32;
        HashMap<Integer, ? extends ItemStack> itemMap = inventory.all(Material.BEACON);

        for (Map.Entry<Integer, ? extends ItemStack> entry : itemMap.entrySet()) {
            if (productAmount == 0) break;
            if (entry.getValue().getType().equals(Material.BEACON)) {
                if (productAmount >= entry.getValue().getAmount()) {
                    inventory.clear(entry.getKey());
                    productAmount -= entry.getValue().getAmount();
                } else {
                    ItemStack result = entry.getValue();
                    result.setAmount(entry.getValue().getAmount() - productAmount);
                    inventory.setItem(entry.getKey(), result);
                    productAmount = 0;
                }
            }
        }

Zitat von zM4xi

Ich kann dir aber nicht versichern das das 100 % so klappt hab es nicht getestet.

Das weiß ich eben nicht an sich speichert das ItemStack[] ja nicht das Objekt selbst sondern die Referenz zu dem Objekt deswegen dachte ich mir das es vielleicht funktioniert Aber wie bereits gesagt keine Garantie

So zunächst die Klasse ItemStackWithSlot:

package test.item;

import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;

public class ItemStackWithSlot extends ItemStack {

    private int slot;

    public ItemStackWithSlot(Material type, int amount, int slot) {
        super(type, amount);
        this.slot = slot;
    }

    public ItemStackWithSlot(Material type, int amount, short damage, int slot) {
        super(type, amount, damage);
        this.slot = slot;
    }

    public ItemStackWithSlot(ItemStack stack, int slot) throws IllegalArgumentException {
        super(stack);
        this.slot = slot;
    }

    public int getSlot() {
        return slot;
    }
}

Damit kannst du einfach deine gewöhnlichen ItemStacks übernehmen bzw. direkt neue anlegen.

Damit die auch ein Anwedungsbeispiel hast.

        Inventory inventory = Bukkit.createInventory(null, 2*9);

        ItemStackWithSlot itemStack = new ItemStackWithSlot(Material.ACACIA_DOOR, 1, 1);
        System.out.println(itemStack.getSlot());

        ItemStack oldItemStack = new ItemStack(Material.ACACIA_DOOR, 1);
        ItemStackWithSlot itemStackWithSlot = new ItemStackWithSlot(oldItemStack, 15);

        inventory.addItem(itemStack);

        ItemStackWithSlot result = null;

        for (ItemStack item : inventory.getContents()) {
            if(item instanceof ItemStackWithSlot) {
                System.out.println("HasSlot");
                result = (ItemStackWithSlot) item;
            }
        }
        System.out.println(result.getSlot());

Ich kann dir aber nicht versichern das das 100 % so klappt hab es nicht getestet.

Wenn es den Slot nicht mit überträgt ins ItemStack Array des Inventares dann müsstet du das ganze einfach manuel per HashMap speichern;

Ein "Mapping" bedeutet das du gewissermaßen einen Gegenstand virtualisierst . Oder anders gesagt du baust dir eine "Anleitung" wie etwas aussieht/zusammengebaut ist/welche Eigenschaften es hat/etc. Gerade bei ItemStack relativ schreibaufwändig wenn man es richtig machen will aber der wohl einfachste weg wäre folgender:

public class ItemStackWIthSlot {

private int slot;
private ItemStack itemStack;

public ItemStackWithSlot(int slot, ItemStack itemStack) {
    this.slot = slot;
    this.itemStack = itemStack;
}

/* GETTER & SETTER */

.
.
.

}

WARNUNG: je nachdem wie du das speicherst sieht es nicht wirklich leserlich aus. bzw ist bei der Bukkit YAMLConfiguration nicht mal vollständig

Wenn du jetzt anstatt reinen ItemStacks dieses Objekt speichert kannst du ganz einfach speichern auf welchem Slot das Item war/ist.

Sollte dir OOP noch fremd sein oder du bist darin nicht sehr geübt rate ich einfach eine HashMap<Integer, ItemStack> ist schnell einfach und kann in einer Config gespeichert werden!

Eigentlich nicht besonders kompliziert.

Aber etwas Können gehört dazu

Zuerst speicherst du am besten immer die Blocklocation der Kisten, dann zum sichern des Inhalt abfragen beim Öffnen von Kisten ob es eine der gespeicherten Locations ist, Ausnahme der Besitzter natürlich.

Nun zum Schild, das Schild aktualisierst du am Besten bei jedem Ver- /Kauf und wenn der Inhaber die Kiste schließt. Somit sollte das Schild immer aktuelle Werte anzeigen.

Um das Schild zu erstellen kannst du 2 wählen zwischen via Command oder direkt per Hand schreiben.

Via Command hat den Vorteil du kannst das Schild nachträglich ändern ohne das man es erst abreißen und neuplatzieren muss.

Per Schild ist eigentlich ja selbsterklärend, beim SignChangeEvent die Zeilen abfragen und nach den Informationen prüfen.

Die Itemanzahl in der Kiste zählen geht indem du den Block der gespeicherten Location bekommst und dann checkst ob es ein Container ist (Keyword: instanceof) ist das der Fall zu einem Container casten und den Inhalt zählen.

Zum Thema automatische Itemerkennung, das ist etwas knifflig entweder beim in die Kiste legen prüfst du das nur ein Typ Item drinne ist oder du lässt den Spieler per Hand schreiben/per Command welches Item verkauft/gekauft werden soll.

Da du schon geschrieben hast es die Items erkennen soll hier wie es geht:

Beim Container schließen prüfen ob nur ein Typ Item in der Kiste ist falls nicht, Inventar wieder öffnen oder optional einfach alle Items droppen. (Hier kannst du, wenn du gerne Algoryhtmen schreibst, nur die Itemtypen droppen die in der Minderheit sind)

Dann bei Command/Schild platzieren einfach wieder auf den Block bzw den Container zugreifen und die Items "auslesen"

Eine Suche in Google erstes Ergebnis btw.
https://www.npmjs.com/package/uuid

Es wäre zum einen schonmal gut wenn wir wissen um welche Sprache es sich hier handeln soll, dementsprechend gibt es vielleicht wie z.B. Java oder PHP UUID in C' gibts Guid's etc

Und dann die Frage speicherst du das in ner Datenbank? Wenn ja einfach ne Spalte uniqueUserId INT AUTO_INCREMENT PRIMARY KEY machen?

Zitat von Pierre

2. Spieler in Creative Mode setzen, und InventoryOpen, BlockPlace, BlockBreak Events und so weiter selber handeln.

Das Problem dabei is nur das er dann auich keinen Schaden bekommt oder Leben hat er müsste eigentlich einen komplett eigenen Gamemode entwickeln

Die wohl einfachste Variante ist, wie Pierre schon sagte, ein Ressourcepack und das dann "Forcen"

Allerdings kannst du natürlich auch versuchen Vehicle Packets zu senden. Wie das geht kann ich dir aber leider nicht sagen.

Ja die .bat oder .cmd (kp was es war) ausführen mit der man die minecraft-server jar decompiled!

Naja die ersten 7 Fehler sagen Type Missmatch!

Der Rest sieht so aus als wären es Folgefehler der Type Missmatches!

Ich rate einfach mal MCP neu zu laden.

Das was du brauchst um zu checken in welche Richtung das Schild zeigt nennt sich BlockFace 

Damit kannst du festlegen in welche Richtung das Schild guckt

Zitat von JD1992

Versuch doch mal deine Hashmap anders zu befüllen. Soweit ich weiß hat das befüllen mithilfe einer anonymen klasse einige seiteneffekte und kann zu Fehlverhalten führen in gewissen Konstellationen.

Also Map deklarieren, dann einzeln Elemente hinzufügen und dann map in das Jason packen.

Das habe ich bereits ich hab versucht direkt den Datentyp Map / List zu setzten in die Map hat aber das selbe Ergebnis hervorgebracht.

Admiral_Zott

Ist zwar ganz nett so aber mein Ziel ist mit dieser Datei gewesen EINE Klasse zu haben die ich einfach importiere und fertig.

Und das das mit den Properties nicht klappt erklärt sich einfach dadurch das eine .properties Datei schon von der Struktur her nicht in der Lage ist irgendeine Art von "Complex Datatype" anzuzeigen.

struktur="einer"
property="file"

OKAY WOW...

ich hab mein "Fehler" gefunden oder sollte ich sagen das Hirngespinst von JAVA

Also das Problem waren die Doppelten geschweiften Klammern anscheinend interpretiert Java die so als wäre kein Konstruktor vorhanden zumindest hat Gson dann das hier {} als Konstruktor beim auslesen. Naja wenn man sich seine Finger bricht und die 2 extra Zeilen schreibt erkennt Gson auch den Konstruktor und bekommt nicht null raus.

UND JA ich weine innerlich

Also für alle Schreibfaulen die das selbe Problem haben schreib die Deklarierung, Initialisierung und die Befüllung in einzelne Zeilen dann ist das Problem gelöst

Ok im Anhang die Configuration Klasse

Aber an setMap() liegt es sicher nicht. Ich setzte wortwörtlich nur die Value in der HashMap sonst nichts

Zu Json und somit in die File gespeichert wird es erst in save().

Ich werde mal versuchen das ganze so umzubauen anstatt den Objekten direkt nur die Json Strings zu speichern aber das ist dann wiederum mit ner Menge de/serializen verbunden für jedes einzelen Objekt das gepsiechert wird.

Ja also ich hab die aktuellste Version von Gson (2.8.5).

Ich habe ein sehr seltsames Verhalten beobachtet. Ich habe den Code von dir kopiert und ausprobiert funktioniert auch wie bei dir einwandfrei. Nun überschreibe ich die HashMap der Configuration Klasse direkt mit einem Setter und dann funktioniert das auch über die Configuration Klasse.

Sobald ich allerdings die Werte einzeln in die HashMap einfüge kann Gson es auf einmal nicht mehr lesen und ich kann einfach nicht verstehen wieso!

LinkedHashMap<String, Object> map = new LinkedHashMap<>();        
serializeHashMapTest();
Configuration.JSON json = new Configuration.JSON(file, "plswork");

json.setDataMap(map);
json.save();

Ergebniss:

{
  "Int": 1337,
  "IntArray": [
    23,
    42
  ],
  "ArrayList": [
    "eins",
    "zwei"
  ],
  "HashMap": {
    "one": 1,
    "two": 2
  }
}

Und dann so:

LinkedHashMap<String, Object> map = new LinkedHashMap<>();        

Configuration.JSON json = new Configuration.JSON(file, "plswork");

json.set("testInt", 15);

json.setMap("fixedMap", new HashMap<String, Integer>() {{
    put("test", 15);
    put("test2", 123);
}});

json.setString("string", "test");

json.set("Map", new HashMap<String, Integer>() {{
    put("test", 15);
    put("newtest", 13823);
}});

Ergebniss:

{
  "testInt": 15,
  "fixedMap": null,
  "string": "test",
  "Map": null
}

Die Map zum internen speichern in der Configuration Klasse ist ebenfalls eine LinkedHashMap mit den selben Typ Parametern.

Hey Leute,

habe ein kleines Problem ich arbeite gerade mit Gson und versuche in einer LinkedHashMap<String, Object> eine HashMap zu speichern sozusagen wie folgt:

        LinkedHashMap<String, Object> dataMap = new LinkedHashMap<>();
        HashMap<?, ?> hashMap = new HashMap<>();
        dataMap.put("key", hashMap);

Nun will aber Gson aus irgendeinem Grund die Map nicht serialisieren. Auch eine ArrayList klappt nicht allgemein alle complexen Datentypen. Lustigerweise funktionieren eigene Klassen einwandfrei

Folgende Methode führe ich aus

    public static void json() throws Exception {

        Configuration.JSON json = new Configuration.JSON(file, "help");

        json.set("testKey", 1515.0);
        json.set("anotherOne", "Hello World xD!");

        Map<Integer, String> map = new HashMap<Integer, String>() {{
            put(1, "Welcome");
            put(2, "To this");
            put(3, "Shitshow");
        }};

        List<String> list = new ArrayList<String>() {{
            add("1232");
            add("1sasdasd");
        }};

        json.set("list", list);
        json.set("map", map);

        json.set("person", new Person("Maxi", 20, 150));

        json.save();

        json = new Configuration.JSON(file, "help");
        json.load();

        double testKey = json.get("testKey", Double.class);
        String anotherOne = json.get("anotherOne", String.class);

        System.out.println(testKey);
        System.out.println(anotherOne);

    }

Und in der Datei bekomme ich folgendes Ergebnis:

{
  "testKey": 1515.0,
  "anotherOne": "Hello World xD!",
  "list": null,
  "map": null,
  "person": {
    "name": "Maxi",
    "age": 20,
    "balance": 150.0
  }
}

Hier noch die verwendeten Methoden:

    @Getter
    protected LinkedHashMap<String, Object> dataMap = new LinkedHashMap<>();

        @Getter
        private final Gson gson = new GsonBuilder().serializeNulls().setPrettyPrinting()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
                .enableComplexMapKeySerialization().create();    


        @Override
        public void save(File file) throws IOException {
            BufferedWriter writer = Files.newBufferedWriter(file.toPath(), Charset.defaultCharset(), StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE);
            gson.toJson(dataMap, LinkedHashMap.class, writer);
            writer.flush();
        }

        @Override
        public void load(File file) throws IOException {
            dataMap = file.length() > 0 ? gson.fromJson(Files.newBufferedReader(file.toPath(), Charset.defaultCharset()), LinkedHashMap.class) : new LinkedHashMap<>();
        }

Ich hoffe irgend jemand weiß wieso die einfach nicht serialisieren wollen. Ich habe auch schon einen Test gemacht ohne die überliegende HashMap (direkt HashMap nach Json) das funktioniert ohne Probleme ich vermute dass es daran liegt das ich die HashMap/List/etc. als Object zwischenspeichere bin mir aber nicht sichern.

Gut mit der Gefahr das jemand das Programm decompiled muss man wohl bei Java leider immer rechnen.

Nun vermutlich wäre tatsächlich die beste Lösung wie schon LGA1151 angedeutet hat die Authentifizierung auf einen für Dritte unzugänglichen Service auszulagern.

Dabei fallen mir 2 Wege ein.

Datenbank oder REST-API

Wobei natürlich die REST-API das mit Abstand der beste wäre da wirklich der komplete Code für die Authentifizierung außer Reichweite Dritter liegt. Und alles was sie aus einer Response erhalten würden wäre true oder false.

Nun zum eigentlichen Thema:

Schreibe dir eine eigene Session Klasse. Ist nicht sehr schwer, alles was du brauchst ist der Zeitpunkt der letzten Aktion nun legst du einen maximale Dauer fest zur letzten Aktivität, sollte diese überschritten werden einfach die Session "schließen". Bei jeder Aktion prüfst du ob die Session schon abgelaufen ist, falls ja muss der Nutzer sich zuerst wieder einloggen

Natürlich bei jeder Aktion die SessionActivity updaten

import java.time.Duration;
import java.time.LocalTime;

public class Session {

    private LocalTime recentActivityTime;
    private Duration sessionTimeout;

    public Session() {
        this.recentActivityTime = LocalTime.now();
        //Change this as u like or use the other Constructor
        this.sessionTimeout = Duration.ofMinutes(60);
    }

    public Session(int sessionTimeoutInMinutes) {
        this.recentActivityTime = LocalTime.now();
        this.sessionTimeout = Duration.ofMinutes(sessionTimeoutInMinutes);
    }
    
    public void updateRecentActivity() {
        this.recentActivityTime = LocalTime.now();
    }

    public boolean isClosed() {
        return LocalTime.now().isAfter(this.recentActivityTime.plus(this.sessionTimeout));
    }

}

PS:

Zitat von DerSchlawiner

---

1) Große Programme bzw. Spiele entsprechen nicht der Performance einer neueren Sprache. Siehe Minecraft.

2) Java würde ich jetzt nicht als die leichteste Sprache deklarieren...

3) Die Ladezeiten: Ja..ein schönes UI ist auch in JavaFX noch möglich...jedoch bist du bei C# schon 1000x besser dran mit den Ladezeiten als bei Java!

---

Java ist im Vergleich zu einigen anderen Sprachen sehr performant.

Java mag zwar nicht die einfachste zu Lernende / Programmierende Sprache sein aber als Entwickler so einiger Sprachen versichere ich dir das es SEHR angenehm ist einfach eine Variable deklarieren zu können ohne darauf achten zu müssen die Ressource wieder freizugeben Auch was Deployment angeht ist Java ein Traum mit der richtigen IDE kannst du mit nur einem Klick compilen, deploy'n und einen Test starten

Im dritten Punkt gebe ich dir voll Recht JavaFX ist wirklich keine Schönheit aber mal ehrlich das sind "reine" WindowsForms oder WCF auch nicht wirklich. Deswegen gibt es Leute die Frameworks/Libs/etc schreiben um das zu erreichen ich zum Beispiel nutze in C# häufig Modern UI (Windows 8.1 Styled C# WF Framwork) und ich habe zwar noch nie dannach gesucht aber ich bin mir sicher das es auch in Java Design Frameworks gibt.

Hoffe das hat etwas geholfen ;|

Grüße Maxi