ThrowBack als Shield

Play4Lif3 · 30. Oktober 2018

Sehr geehrtes Techleague-Forum,

ich schlage mich seit einigen Stunden mit einem Problem rum:

In meinem Listener (EnterRegionListener) -> WorldGuard:

Code

@EventHandler
public void onEnter(RegionEnterEvent e) {
Player p = e.getPlayer();
if (e.getRegion().getId().equals("spawn")) {
Vector direction = p.getLocation().getDirection();
direction.setX(2.0);
direction.setY(2.0);
direction.setZ(2.0);
p.setVelocity(direction);
p.sendMessage("Du bist noch im Kampf!");
p.sendMessage(pl.getUtil().getData().getCardinalDirection(p));
}
}

Alles anzeigen

Ich möchte, dass ein Spieler, wenn er die Region "spawn" betritt, mit zufälligen Werten zurrückgestossen wird. Ich sitze seit 4 Stunden an diesem "Problem". Entweder bin ich zu beschränkt oder doch zu blöd dafür.

Wenn ich mal eine "Lösung" gefunden habe, dann wird ein Spieler zwar an zwei Seiten zurrückgestossen, aber an den anderen zwei Richtungen nicht. Ich weiss nicht warum. Kann mir vielleicht jemand dabei helfen, dass ein Spieler zurrückgestossen wird, wenn er von allen vier Seiten in diese Region möchte, egal ob vorwärts oder rückwärts oder im Fly-Mode. Ich bin leider mit meinem Latein am ende. Ich habe jetzt eine 30-Stunden Woche hinter mir und ich kann einfach nicht mehr. Wäre Suppi, wenn mir wer Helfen könnte.

Mit freundlichen Grüssen,

Play4Lif3.

**TASSIA710** · 31. Oktober 2018

Ich bin leider auch kein wirklicher Experte in Punkto 3D-Vektor-Mathematik / Vektor-Geometrie / Wie-auch-immer-das-in-Fachsprache-heißt,

deswegen fällt es mir ein bisschen schwer dir das möglichst einfach zu erklären.

Mit meinem bisschen Erfahrung habe ich mal diesen kleinen Befehl hier geschrieben.

Er wirft den Spieler von der Start Position der Welt weg.

Funktionsweise:

Wenn du ihn ausführst, nimmt der einen Punkt (in meinem Fall hier den World Spawn) und die Spieler Position.

Dann errechnet er die Richtung (in Anlage 1 dargestellt).

Die Rechnung dabei ist Folgende:

x = x1 - x2;

z = z1 - z2;

(Neben-Fakt: Wenn du den Spieler zum Mittelpunkt werfen möchtest, ist die Rechnung x = x2 - x1 und z = z2 - z1 )

Y ist egal, da wir die horizontale Richtung wissen wollen.

Die Höhe legen wir später fest.

Mit diesem X und Z Wert konstruieren wir uns einen Richtungsvektor.

Diesen normalisieren wir und multiplizieren ihn dann mit einem Faktor.

Dadurch hat die Entfernung zum Punkt 1 keinen Einfluss auf die Kraft, des Wurfes.

Der Faktor bestimmt wie stark der Wurf sein soll.

Anschließend setzen wir den Y-Wert (Höhe), damit der Spieler auch nach oben

katapultiert wird, und so nicht an irgendwelchen Blöcken am Boden hängenbleibt.

Anschließend werfen wir den Spieler nur noch in die Richtung.

Hier ist einmal der Quellcode:

Java

@Override
public final boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
if(!(sender instanceof Player)) return true;
Player p = (Player) sender;
Vector from = p.getWorld().getSpawnLocation().toVector();
Vector player = p.getLocation().toVector();
// Wie weit soll der Spieler zurückgeworfen werden
final double boostFactor = 2;
// Dieser Wert wirft den Spieler in die Höhe
double y = 1;
// Hier berechnen wir die Richtung, in die der Spieler geworfen werden soll
// Ich habe unten noch ein Zitat angehängt, vielleicht hilft dir das zur Erklärung
double x = player.getX() - from.getX();
double z = player.getZ() - from.getZ();
// Richtungs-Vektor konstruieren
Vector direction = new Vector(x, 0, z);
// Vektor normalisieren (Länge auf 1 setzen, soweit ich weiß) und dann mit dem Boost-Faktor multiplizieren
direction = direction.normalize().multiply(boostFactor);
// Höhe danach setzen (von Normalisierung und Boost-Faktor nicht beeinflusst)
direction.setY(y);
// Spieler in die Richtung katapultieren
p.setVelocity(direction);
return true;
}

Alles anzeigen

Ich habe dir noch ein Zitat rausgesucht, vielleicht verstehst du

damit die Berechnung der Richtung ein bisschen besser.

Sjoerd C. de Vries @ Stack Overflow schrieb:

A nice way to remember which way the subtraction goes is to think of what the vector actually does. Imagine vector v resting at p1, pointing and connecting to p2. This means that p1 + v = p2. Therefore, v = p2-p1

Auf dein Problem angewandt, könntest du den Code in dem RegionEnterEvent-Listener ausführen und statt
dem Weltstartpunkt, den Mittelpunkt der Region wählen. Dann würde der Spieler immer beim betreten der

Region von dessen Mittelpunkt weg- und ergo wieder aus der Region raus geworfen werden.

Aber spiel am besten mal ein bisschen mit dem Befehl herum. Ich glaube irgendwann verstehst du so ein bisschen das Prinzip.

Sollte irgendetwas unklar sein, zögere nicht zu fragen

Play4Lif3 · 31. Oktober 2018

Soweit hatte ich das ganze leider auch schon...

Ich kenne mich zwar ein wenig in 3D-Vector-Mathematik aus, aber ich bin anscheinend zu beschränkt gerade...

Ich habe das jetzt mit der WorldGuard Region gemacht:

Code

@EventHandler
public void onEnter(RegionEnterEvent e) {
Player p = e.getPlayer();
if (e.getRegion().getId().equals("spawn")) {
World w = Bukkit.getWorld(p.getWorld().toString());
Location location = null;
//Hier wird die Region "Spawn" berechnet.
//Aber nur auf zwei Seiten?!
Location top = new Location(w, 0, 0, 0);
top.setX(e.getRegion().getMaximumPoint().getX());
top.setY(e.getRegion().getMaximumPoint().getY());
top.setZ(e.getRegion().getMaximumPoint().getZ());
Location bottom = new Location(w, 0, 0, 0);
bottom.setX(e.getRegion().getMaximumPoint().getX());
bottom.setY(e.getRegion().getMaximumPoint().getY());
bottom.setZ(e.getRegion().getMaximumPoint().getZ());
double X = ((bottom.getX() - top.getX()) / 2) + bottom.getX();
double Y = ((bottom.getY() - top.getY()) / 2) + bottom.getY();
double Z = ((bottom.getZ() - top.getZ()) / 2) + bottom.getZ();
location = new Location(w, X, Y, Z);
System.out.println(location);
//Vectoren
Vector from = location.toVector();
Vector player = p.getLocation().toVector();
//Der rest, wie bei dir.
final double boostFactor = 2;
double y = 1;
double x = player.getX() - from.getX();
double z = player.getZ() - from.getZ();
Vector direction = new Vector(x, 0, z);
direction = direction.normalize().multiply(boostFactor);
direction.setY(y);
p.setVelocity(direction);
p.sendMessage("Du bist noch im Kampf!");
}
}
//Natürlich unordentlich, weil Testen...

Alles anzeigen

Ich habe mal ein Video auf Youtube hochgeladen, damit du weisst, was ich meine.

Link:

Ich danke dir!

**TASSIA710** · 31. Oktober 2018

Java

// Hier benutzt du die Koordinaten vom MaximumPoint
Location top = new Location(w, 0, 0, 0);
top.setX(e.getRegion().getMaximumPoint().getX());
top.setY(e.getRegion().getMaximumPoint().getY());
top.setZ(e.getRegion().getMaximumPoint().getZ());
// Hier benutzt du dieselben Koordinaten?
Location bottom = new Location(w, 0, 0, 0);
bottom.setX(e.getRegion().getMaximumPoint().getX());
bottom.setY(e.getRegion().getMaximumPoint().getY());
bottom.setZ(e.getRegion().getMaximumPoint().getZ());
// Wenn du die selben Koordinaten benutzt heißt das, das bottom.getX() gleich top.getX() ist.
// (auch für Y und Z). Deine Rechnung unten wäre dann folgende (weil beide Koordinaten gleich sind):
// x = ((bottom.getX() - top.getX()) / 2) + bottom.getX();
// x = (0 / 2) + bottom.getX();
// x = bottom.getX();
double X = ((bottom.getX() - top.getX()) / 2) + bottom.getX();
double Y = ((bottom.getY() - top.getY()) / 2) + bottom.getY();
double Z = ((bottom.getZ() - top.getZ()) / 2) + bottom.getZ();
location = new Location(w, X, Y, Z);

Alles anzeigen

Ich verstehe leider nicht ganz, was du mit dem Code versuchst.

So wie er jetzt dasteht, könntest du es doch auch so kürzen:

Java

location = new Location(w,
e.getRegion().getMaximumPoint().getX(),
e.getRegion().getMaximumPoint().getY(),
e.getRegion().getMaximumPoint().getZ());
// (wenn der MaximumPoint nicht schon bereits eine Location ist)

Ich würde den Mittelpunkt der Region so einfach ausrechnen

Java

// (Die Höhe ist immer noch egal)
double xMin = e.getRegion().getMinimumPoint().getX();
double xMax = e.getRegion().getMaximumPoint().getX();
double zMin = e.getRegion().getMinimumPoint().getZ();
double zMax = e.getRegion().getMinimumPoint().getZ();
// Hier dann einfach den Mittelwert/Durchschnitt ausrechnen?
double x = (xMin + xMax) / 2;
double z = (zMin + zMax) / 2;
// Und dann einfach so den Mittelpunkt erstellen:
location = new Location(w, x, 0, z);

Alles anzeigen

Und dann halt wie du es dann auch machst, so weiter arbeiten:

Java

// Vektoren
Vector from = location.toVector();
Vector player = p.getLocation().toVector();
// Der Rest, wie bei dir.
final double boostFactor = 2;
double y = 1;
double x = player.getX() - from.getX();
double z = player.getZ() - from.getZ();
Vector direction = new Vector(x, 0, z);
direction = direction.normalize().multiply(boostFactor);
direction.setY(y);
p.setVelocity(direction);
p.sendMessage("Du bist noch im Kampf!");

Alles anzeigen

Play4Lif3 · 31. Oktober 2018

Okay. Das funktioniert schon besser. Leider habe ich auf einer Seite wieder einen Fehler:

Code

public void onEnter(RegionEnterEvent e) {
Player p = e.getPlayer();
if (pl.getUtil().getShieldConfigManager().getRegionstoBlock().contains(e.getRegion().getId())) {
World w = p.getWorld();
Location location = new Location(w,
e.getRegion().getMaximumPoint().getX(),
e.getRegion().getMaximumPoint().getY(),
e.getRegion().getMaximumPoint().getZ());
double xMin = e.getRegion().getMinimumPoint().getX();
double xMax = e.getRegion().getMaximumPoint().getX();
double zMin = e.getRegion().getMinimumPoint().getZ();
double zMax = e.getRegion().getMinimumPoint().getZ();
double x = (xMin + xMax) / 2;
double z = (zMin + zMax) / 2;
location = new Location(w, x, 0, z);
Vector from = location.toVector();
Vector player = p.getLocation().toVector();
final double boostFactor = 1.5;
double y1 = 1;
double x1 = player.getX() - from.getX();
double z1 = player.getZ() - from.getZ();
Vector direction = new Vector(x1, 0, z1);
direction = direction.normalize().multiply(boostFactor);
direction.setY(y1);
p.setVelocity(direction);
p.sendMessage("Du bist noch im Kampf!");
}
}

Alles anzeigen

Hier nochmal ein Link:

Was mich wundert, dass man je nach dem, wo man steht, einen drall nach links oder rechts hat. Kann man das irgendwie verhindern?

Ich bedanke mich nochmal vielmals!

**TASSIA710** · 31. Oktober 2018

Da bin ich jetzt selber überfragt.

Ich installiere mir mal eben WorldGuard auf meinem lokalen Server

und probiere es selber aus. Wenn ich eine Lösung finde, gebe ich dir Bescheid

**TASSIA710** · 31. Oktober 2018

Also.. folgender Code funktioniert bei mir Einwand frei:

Java

@EventHandler
public final void onRegionEnter(RegionEnterEvent e) {
if(e.getRegion().getId().equals("spawn")) {
// Spieler wieder rauswerfen
// Mittelpunkt der Region berechnen
double x = (e.getRegion().getMinimumPoint().getX() + e.getRegion().getMaximumPoint().getX()) / 2;
double z = (e.getRegion().getMinimumPoint().getZ() + e.getRegion().getMaximumPoint().getZ()) / 2;
// Spieler Position
Vector player = e.getPlayer().getLocation().toVector();
// Richtung berechnen
x = player.getX() - x;
z = player.getZ() - z;
Vector dir = new Vector(x, 0, z);
// Vektor normalisieren (Länge auf 1 setzen, soweit ich weiß) und dann mit dem Boost-Faktor multiplizieren
final double boostFactor = 1.5;
dir = dir.normalize().multiply(boostFactor);
// Höhe danach setzen (von Normalisierung und Boost-Faktor nicht beeinflusst)
final double y = 0.6;
dir.setY(y);
// Spieler werfen
e.getPlayer().setVelocity(dir);
e.getPlayer().sendMessage("Ey, du bist noch im Kampf!");
}
}
}

Alles anzeigen

Zitat

Was mich wundert, dass man je nach dem, wo man steht, einen drall nach links oder rechts hat. Kann man das irgendwie verhindern?

Der Code ist jetzt darauf ausgerichtet, dass er dich immer vom Mittelpunkt der Region, und nicht der Kante der Region wegschleudert.

Einen so starken rechts/links Drall wie in deinem Video sollte er allerdings nicht haben (hat er bei meinem EventListener auch nicht)

Das heißt aber, je nachdem wo an der Kante der Spieler versucht die Region zu betreten, wird die Richtung ein bisschen beeinflusst.

Vielleicht verstehst du mit meiner angehängten Grafik etwas besser was ich meine.

Rot: Regions Mittelpunkt

Grün: Regions Grenze

Blau: Punkte an denen der Spieler versucht, die Region zu betreten

Schwarz: Richtung, in die der Spieler geschleudert wird

Man könnte das Plugin auch so programmieren, dass er von der Kante und nicht vom Mittelpunkt weggeschleudert wird,

das wäre dann aber vermutlich aufwendiger und würde kein bisschen helfen, wenn es momentan bei dir noch nicht mit dem Mittelpunkt klappt.

Falls du es doch probieren willst, hätte ich hier einen Ansatz:

Java

// Dieser Ansatz setzt vorraus, dass die Region Quadratförmig ist.
// Bei einem Rechteck würde es nicht mehr funktionieren.
// ...
// Richtung berechnen
x = player.getX() - x;
z = player.getZ() - z;
Vector dir;
if(Math.abs(x) > Math.abs(z)) dir = new Vector(x, 0, 0);
else dir = new Vector(0, 0, z);
// ...

Alles anzeigen

Mal erklärt:

Bei diesem Ansatz schaust du, in welche Richtung er mehr geworfen wird (x oder z) und lässt dann die andere Richtung komplett weg.

Aber das ist nur ein Ansatz. Es gibt vermutlich eine Menge besserer Lösungen, die auch andere Formen als nur ein Quadrat unterstützen.

Ich schreibe schon wieder viel zu viel, probiers mal mit meinem EventListener (musst ggf. die If-Abfrage abändern)

und schau ob es funktioniert

Play4Lif3 · 31. Oktober 2018

Ich danke dir! Es hat funktioniert und deine Erklärung war verständlich. Das mit der Kante hat auf Anhieb funktioniert.

Für das nächste mal für mich:

**TASSIA710** · 31. Oktober 2018

Immer wieder gerne

ThrowBack als Shield

EurenikZ 31. Oktober 2018

Teilen

Tags