diff --git a/src/de/steamwar/misslewars/countdowns/ItemCountdown.java b/src/de/steamwar/misslewars/countdowns/ItemCountdown.java index f5050ee..4bb8e12 100644 --- a/src/de/steamwar/misslewars/countdowns/ItemCountdown.java +++ b/src/de/steamwar/misslewars/countdowns/ItemCountdown.java @@ -29,12 +29,10 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.scheduler.BukkitTask; import java.util.EnumSet; -import java.util.Random; public class ItemCountdown extends StateDependent { private BukkitTask task; - private Random random = new Random(); public ItemCountdown() { super(EnumSet.of(FightState.FIGHTING)); diff --git a/src/de/steamwar/misslewars/items/SpecialItem.java b/src/de/steamwar/misslewars/items/SpecialItem.java index b66c04c..147bc38 100644 --- a/src/de/steamwar/misslewars/items/SpecialItem.java +++ b/src/de/steamwar/misslewars/items/SpecialItem.java @@ -20,13 +20,14 @@ package de.steamwar.misslewars.items; import org.bukkit.Material; -import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemFlag; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; public abstract class SpecialItem { diff --git a/src/de/steamwar/misslewars/items/arrows.json b/src/de/steamwar/misslewars/items/arrows.json index f2d3ddc..69c6246 100644 --- a/src/de/steamwar/misslewars/items/arrows.json +++ b/src/de/steamwar/misslewars/items/arrows.json @@ -1,16 +1,68 @@ -{ - "type": "ARROW", - "name": "§ePfeil", - "lore": [], - "amount": 3, - "EVENT.onThrow": [ +[ + { + "type": "ARROW", + "name": "§ePfeil", + "lore": [], + "amount": 3, + "EVENT.onThrow": [ - ], - "EVENT.onHit": [ - {"type": "delay", "time": 0}, - {"type": "paste", "schem": ""} - ], - "EVENT.onClick": [ + ], + "EVENT.onHit": [ - ] -} \ No newline at end of file + ], + "EVENT.onClick": [ + + ] + }, + { + "type": "SPECTRAL_ARROW", + "name": "§eExplodierender Pfeil", + "lore": [], + "amount": 1, + "EVENT.onHit": [ + {"type": "summon", "entity": "TNTPrimed", "incendiary": false, "fuse": 0, "yield": 2.0} + ] + }, + { + "type": "FIRE_CHARGE", + "name": "§eFeuerball", + "lore": [], + "amount": 1, + "EVENT.onClick": [ + {"type": "launch", "entity": "Fireball", "incendiary": false, "bounce": false, "yield": 3.0, "velocity": 2}, + {"type": "sound", "sound": "ITEM_FIRECHARGE_USE", "volume": 100, "pitch": 1} + ] + }, + { + "type": "SLIME_BALL", + "name": "§aLanding Pad", + "lore": [], + "amount": 1, + "EVENT.onClick": [ + {"type": "potion", "potion": "SLOW_FALLING", "duration": 2, "amplifier": 1, "ambient": false, "particles": false, "icon": false}, + {"type": "paste", "schem": "landingPad.schem", "centered": true, "offset": [0, -5, 0], "ignoreAir": true} + ] + }, + { + "type": "EGG", + "name": "§eMine", + "lore": [], + "amount": 1, + "EVENT.onThrow": [ + {"type": "delay", "time": "CONFIG.MineFlyTime"}, + {"type": "filter", "filter": "nearPortal", "invert": true}, + {"type": "paste", "schem": "mine.schem", "centered": true, "offset": [0, 0, 0], "ignoreAir": true} + ] + }, + { + "type": "SNOWBALL", + "name": "§aSchild", + "lore": [], + "amount": 1, + "EVENT.onThrow": [ + {"type": "delay", "time": "CONFIG.ShieldFlyTime"}, + {"type": "filter", "filter": "nearPortal", "invert": true}, + {"type": "paste", "schem": "shield.schem", "centered": true, "offset": [0, 0, 0], "ignoreAir": true} + ] + } +] \ No newline at end of file diff --git a/src/de/steamwar/misslewars/scripts/RunnableScript.java b/src/de/steamwar/misslewars/scripts/RunnableScript.java new file mode 100644 index 0000000..1ae8fd2 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/RunnableScript.java @@ -0,0 +1,40 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts; + +import org.bukkit.entity.Entity; + +public interface RunnableScript { + + class RunnableScriptEvent { + + public final ScriptedItem.EventType eventType; + public final Entity entity; + + public RunnableScriptEvent(ScriptedItem.EventType eventType, Entity entity) { + this.eventType = eventType; + this.entity = entity; + } + + } + + boolean execute(RunnableScriptEvent runnableScriptEvent); + +} diff --git a/src/de/steamwar/misslewars/scripts/Script.java b/src/de/steamwar/misslewars/scripts/Script.java new file mode 100644 index 0000000..b4a9136 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/Script.java @@ -0,0 +1,49 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts; + +import de.steamwar.misslewars.MissileWars; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; + +import java.util.ArrayList; +import java.util.List; + +public class Script { + + private List runnableScriptList = new ArrayList<>(); + + public void execute(RunnableScript.RunnableScriptEvent runnableScriptEvent) { + Bukkit.getScheduler().runTaskLater(MissileWars.getPlugin(), () -> { + int i = 0; + while (i < runnableScriptList.size()) { + if (!runnableScriptList.get(i).execute(runnableScriptEvent)) { + break; + } + i++; + } + }, 0); + } + + public void add(RunnableScript runnableScript) { + runnableScriptList.add(runnableScript); + } + +} diff --git a/src/de/steamwar/misslewars/scripts/ScriptParser.java b/src/de/steamwar/misslewars/scripts/ScriptParser.java new file mode 100644 index 0000000..346fb77 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/ScriptParser.java @@ -0,0 +1,64 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import de.steamwar.misslewars.scripts.implemented.*; + +public class ScriptParser { + + public static Script parseScript(JsonArray jsonArray) { + Script script = new Script(); + jsonArray.forEach(jsonElement -> { + if (!jsonArray.isJsonObject()) return; + RunnableScript runnableScript = parseScriptSnippet((JsonObject) jsonElement); + if (runnableScript == null) return; + script.add(runnableScript); + }); + return script; + } + + private static RunnableScript parseScriptSnippet(JsonObject jsonObject) { + if (!jsonObject.has("type")) { + return null; + } + String type = jsonObject.getAsJsonPrimitive("type").getAsString(); + switch (type.toLowerCase()) { + case "delay": + return new DelayScript(jsonObject); + case "filter": + return new FilterScript(jsonObject); + case "launch": + return new LaunchScript(jsonObject); + case "paste": + return new PasteScript(jsonObject); + case "potion": + return new PotionScript(jsonObject); + case "sound": + return new SoundScript(jsonObject); + case "summon": + return new SummonScript(jsonObject); + default: + return null; + } + } + +} diff --git a/src/de/steamwar/misslewars/scripts/ScriptedItem.java b/src/de/steamwar/misslewars/scripts/ScriptedItem.java new file mode 100644 index 0000000..c256c04 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/ScriptedItem.java @@ -0,0 +1,102 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import org.bukkit.Material; +import org.bukkit.entity.Entity; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class ScriptedItem { + + // "type": Material name (STRING) + // "name": Item name (STRING) + // "lore": Lore array (OPTIONAL STRING.ARRAY) + // "amount": Item amount (OPTIONAL [default 1] INT) + // "EVENT.": Event (OPTIONAL JSONobject.ARRAY) + // - onClick + // - onHit + // - onThrow + + public enum EventType { + onHit("onHit"), + onThrow("onThrow"), + onClick("onClick"); + + String name; + + EventType(String name) { + this.name = name; + } + } + + private Map scriptMap = new HashMap<>(); + + private ItemStack itemStack; + + public ScriptedItem(JsonObject jsonObject) { + itemStack = createItemStack(jsonObject); + + for (EventType eventType : EventType.values()) { + String eventString = "EVENT." + eventType.name(); + if (!jsonObject.has(eventString)) continue; + if (!jsonObject.get(eventString).isJsonArray()) continue; + scriptMap.put(eventType, ScriptParser.parseScript(jsonObject.getAsJsonArray(eventString))); + } + } + + private ItemStack createItemStack(JsonObject jsonObject) { + String type = jsonObject.getAsJsonPrimitive("type").getAsString(); + String name = jsonObject.getAsJsonPrimitive("name").getAsString(); + int amount = jsonObject.getAsJsonPrimitive("amount").getAsInt(); + + ItemStack itemStack = new ItemStack(Material.valueOf(type), amount); + ItemMeta itemMeta = itemStack.getItemMeta(); + if (itemMeta == null) return itemStack; + itemMeta.setDisplayName(name); + + if (jsonObject.has("lore")) { + List lore = new ArrayList<>(); + jsonObject.getAsJsonArray("lore").forEach(jsonElement -> { + if (!jsonElement.isJsonPrimitive()) { + return; + } + lore.add(jsonElement.getAsString()); + }); + itemMeta.setLore(lore); + } + + itemStack.setItemMeta(itemMeta); + return itemStack; + } + + public void execute(EventType eventType, Entity entity) { + if (!scriptMap.containsKey(eventType)) return; + scriptMap.get(eventType).execute(new RunnableScript.RunnableScriptEvent(eventType, entity)); + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/DelayScript.java b/src/de/steamwar/misslewars/scripts/implemented/DelayScript.java new file mode 100644 index 0000000..137dba4 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/DelayScript.java @@ -0,0 +1,73 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; +import de.steamwar.misslewars.Config; +import de.steamwar.misslewars.scripts.RunnableScript; + +public class DelayScript implements RunnableScript { + + private int delayTime = 0; + + public DelayScript(JsonObject delay) { + JsonPrimitive jsonPrimitive = delay.getAsJsonPrimitive("time"); + if (jsonPrimitive.isString()) { + switch (jsonPrimitive.getAsString().toLowerCase()) { + case "config.mineflytime": + case "config.shiledflytime": + delayTime = Config.ShieldFlyTime; + break; + case "config.endtime": + delayTime = Config.EndTime; + break; + case "config.waitingtime": + delayTime = Config.WaitingTime; + break; + case "config.itemtime": + delayTime = Config.ItemTime; + break; + case "config.platformtime": + delayTime = Config.PlatformTime; + break; + + case "tick": + delayTime = 1; + break; + default: + break; + } + } else { + delayTime = jsonPrimitive.getAsInt(); + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + try { + Thread.sleep(delayTime); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/FilterScript.java b/src/de/steamwar/misslewars/scripts/implemented/FilterScript.java new file mode 100644 index 0000000..50246d5 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/FilterScript.java @@ -0,0 +1,82 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import de.steamwar.misslewars.MissileWars; +import de.steamwar.misslewars.scripts.RunnableScript; +import org.bukkit.Location; + +public class FilterScript implements RunnableScript { + + private interface Filter { + + boolean filter(RunnableScriptEvent runnableScriptEvent); + + } + + private boolean inverted = false; + private Filter filter = null; + + public FilterScript(JsonObject filter) { + switch (filter.getAsJsonPrimitive("filter").getAsString().toLowerCase()) { + case "nearportal": + this.filter = runnableScriptEvent -> { + Location location = runnableScriptEvent.entity.getLocation(); + int bz = MissileWars.getBlueTeam().getPortalZ(); + int rz = MissileWars.getRedTeam().getPortalZ(); + + int offset = sign(bz - rz) * 5; + + int blockZ = location.getBlockZ(); + if (offset > 0) { + if (blockZ > bz - offset) return false; + if (blockZ < rz + offset) return false; + } else { + if (blockZ < bz - offset) return false; + if (blockZ > rz + offset) return false; + } + return true; + }; + break; + default: + break; + } + if (filter.has("invert")) { + inverted = filter.getAsJsonPrimitive("invert").getAsBoolean(); + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + if (filter == null) return true; + if (inverted) { + return !filter.filter(runnableScriptEvent); + } else { + return filter.filter(runnableScriptEvent); + } + } + + private int sign(int i) { + if (i < 0) return -1; + return i > 0 ? 1 : 0; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/LaunchScript.java b/src/de/steamwar/misslewars/scripts/implemented/LaunchScript.java new file mode 100644 index 0000000..1af6fe4 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/LaunchScript.java @@ -0,0 +1,79 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import de.steamwar.misslewars.scripts.RunnableScript; +import de.steamwar.misslewars.scripts.ScriptedItem; +import org.bukkit.entity.*; + +import static de.steamwar.misslewars.scripts.utils.EntityUtils.*; + +public class LaunchScript implements RunnableScript { + + private interface Launch { + + void launch(RunnableScriptEvent runnableScriptEvent); + + } + + private Launch launch = null; + + public LaunchScript(JsonObject launch) { + switch (launch.getAsJsonPrimitive("entity").getAsString().toLowerCase()) { + case "fireball": + this.launch = runnableScriptEvent -> { + Player player = (Player) runnableScriptEvent.entity; + Fireball fireball = player.launchProjectile(Fireball.class); + + setVelocity(fireball, launch); + setYield(fireball, launch); + setIncendiary(fireball, launch); + setBounce(fireball, launch); + setGlowing(fireball, launch); + setGravity(fireball, launch); + + fireball.setDirection(player.getLocation().getDirection()); + }; + break; + case "arrow": + this.launch = runnableScriptEvent -> { + Player player = (Player) runnableScriptEvent.entity; + Arrow arrow = player.launchProjectile(Arrow.class); + + setVelocity(arrow, launch); + setGlowing(arrow, launch); + setGravity(arrow, launch); + }; + break; + default: + break; + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + if (launch == null) return false; + if (runnableScriptEvent.eventType != ScriptedItem.EventType.onClick) return true; + launch.launch(runnableScriptEvent); + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/PasteScript.java b/src/de/steamwar/misslewars/scripts/implemented/PasteScript.java new file mode 100644 index 0000000..742d0a4 --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/PasteScript.java @@ -0,0 +1,100 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.WorldEdit; +import com.sk89q.worldedit.bukkit.BukkitWorld; +import com.sk89q.worldedit.extent.clipboard.Clipboard; +import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats; +import com.sk89q.worldedit.function.operation.Operations; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.session.ClipboardHolder; +import com.sk89q.worldedit.world.World; +import de.steamwar.misslewars.MissileWars; +import de.steamwar.misslewars.scripts.RunnableScript; +import org.bukkit.Bukkit; +import org.bukkit.Location; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.util.Objects; + +public class PasteScript implements RunnableScript { + + private static final World world = new BukkitWorld(Bukkit.getWorlds().get(0)); + + private final Clipboard clipboard; + private final BlockVector3 centeredOffset; + + private boolean centered = false; + private boolean ignoreAir = false; + private int xOffset = 0; + private int yOffset = 0; + private int zOffset = 0; + + public PasteScript(JsonObject paste) { + String schemFileName = paste.getAsJsonPrimitive("schem").getAsString(); + if (!schemFileName.endsWith(".schem")) { + schemFileName += ".schem"; + } + + File schemFile = new File(MissileWars.getPlugin().getDataFolder(), schemFileName); + try { + clipboard = Objects.requireNonNull(ClipboardFormats.findByFile(schemFile)).getReader(new FileInputStream(schemFile)).read(); + } catch (IOException e) { + throw new SecurityException("Could not load shield", e); + } + centeredOffset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin()).add(clipboard.getDimensions().divide(2)); + + if (paste.has("centered")) { + centered = paste.getAsJsonPrimitive("centered").getAsBoolean(); + } + if (paste.has("ignoreAir")) { + ignoreAir = paste.getAsJsonPrimitive("ignoreAir").getAsBoolean(); + } + if (paste.has("offset")) { + JsonArray jsonArray = paste.getAsJsonArray("offset"); + if (jsonArray.size() == 3) { + xOffset = jsonArray.get(0).getAsInt(); + yOffset = jsonArray.get(1).getAsInt(); + zOffset = jsonArray.get(2).getAsInt(); + } + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + Location location = runnableScriptEvent.entity.getLocation(); + BlockVector3 paste = BlockVector3.at(location.getX() + xOffset, location.getY() + yOffset, location.getZ() + zOffset); + if (centered) { + paste = paste.subtract(centeredOffset); + } + + EditSession editSession = WorldEdit.getInstance().getEditSessionFactory().getEditSession(world, -1); + Operations.completeBlindly(new ClipboardHolder(clipboard).createPaste(editSession).ignoreAirBlocks(ignoreAir).to(paste).build()); + editSession.flushSession(); + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/PotionScript.java b/src/de/steamwar/misslewars/scripts/implemented/PotionScript.java new file mode 100644 index 0000000..26f574f --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/PotionScript.java @@ -0,0 +1,72 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import de.steamwar.misslewars.scripts.RunnableScript; +import de.steamwar.misslewars.scripts.ScriptedItem; +import org.bukkit.entity.Player; +import org.bukkit.potion.PotionEffect; +import org.bukkit.potion.PotionEffectType; + +public class PotionScript implements RunnableScript { + + private PotionEffect potionEffect = null; + + public PotionScript(JsonObject potion) { + int duration = 1; + int amplifier = 1; + boolean ambient = true; + boolean particles = true; + boolean icon = true; + + if (potion.has("duration")) { + duration = potion.getAsJsonPrimitive("duration").getAsInt(); + } + if (potion.has("amplifier")) { + amplifier = potion.getAsJsonPrimitive("amplifier").getAsInt(); + } + if (potion.has("ambient")) { + ambient = potion.getAsJsonPrimitive("ambient").getAsBoolean(); + } + if (potion.has("particles")) { + particles = potion.getAsJsonPrimitive("particles").getAsBoolean(); + } + if (potion.has("icon")) { + icon = potion.getAsJsonPrimitive("icon").getAsBoolean(); + } + + PotionEffectType potionEffectType = PotionEffectType.getByName(potion.getAsJsonPrimitive("potion").getAsString()); + if (potionEffectType == null) { + return; + } + potionEffect = new PotionEffect(potionEffectType, duration, amplifier, ambient, particles, icon); + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + if (potionEffect == null) return false; + if (runnableScriptEvent.eventType != ScriptedItem.EventType.onClick) return true; + Player player = (Player) runnableScriptEvent.entity; + player.addPotionEffect(potionEffect); + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/SoundScript.java b/src/de/steamwar/misslewars/scripts/implemented/SoundScript.java new file mode 100644 index 0000000..eead78a --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/SoundScript.java @@ -0,0 +1,53 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import de.steamwar.misslewars.scripts.RunnableScript; +import de.steamwar.misslewars.scripts.ScriptedItem; +import org.bukkit.Sound; +import org.bukkit.entity.Player; + +public class SoundScript implements RunnableScript { + + private Sound sound; + private float volume = 100; + private float pitch = 1; + + public SoundScript(JsonObject sound) { + this.sound = Sound.valueOf(sound.getAsJsonPrimitive("sound").getAsString()); + if (sound.has("volume")) { + volume = sound.getAsJsonPrimitive("volume").getAsFloat(); + } + if (sound.has("pitch")) { + pitch = sound.getAsJsonPrimitive("pitch").getAsFloat(); + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + if (sound == null) return false; + if (runnableScriptEvent.eventType != ScriptedItem.EventType.onClick) return true; + Player player = (Player) runnableScriptEvent.entity; + player.playSound(player.getLocation(), sound, volume, pitch); + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/implemented/SummonScript.java b/src/de/steamwar/misslewars/scripts/implemented/SummonScript.java new file mode 100644 index 0000000..7af36af --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/implemented/SummonScript.java @@ -0,0 +1,62 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.implemented; + +import com.google.gson.JsonObject; +import de.steamwar.misslewars.scripts.RunnableScript; +import org.bukkit.entity.Entity; +import org.bukkit.entity.TNTPrimed; + +import static de.steamwar.misslewars.scripts.utils.EntityUtils.*; + +public class SummonScript implements RunnableScript { + + private interface Summon { + + void summon(Entity entity); + + } + + private Summon summon = null; + + public SummonScript(JsonObject summon) { + switch (summon.getAsJsonPrimitive("entity").getAsString().toLowerCase()) { + case "tntprimed": + this.summon = entity -> { + TNTPrimed tnt = entity.getWorld().spawn(entity.getLocation(), TNTPrimed.class); + + setYield(tnt, summon); + setIncendiary(tnt, summon); + setFuseTime(tnt, summon); + }; + break; + default: + break; + } + } + + @Override + public boolean execute(RunnableScriptEvent runnableScriptEvent) { + if (summon == null) return false; + summon.summon(runnableScriptEvent.entity); + return true; + } + +} diff --git a/src/de/steamwar/misslewars/scripts/utils/EntityUtils.java b/src/de/steamwar/misslewars/scripts/utils/EntityUtils.java new file mode 100644 index 0000000..d3025fe --- /dev/null +++ b/src/de/steamwar/misslewars/scripts/utils/EntityUtils.java @@ -0,0 +1,79 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.misslewars.scripts.utils; + +import com.google.gson.JsonObject; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Explosive; +import org.bukkit.entity.Projectile; +import org.bukkit.entity.TNTPrimed; + +public class EntityUtils { + + public static void setVelocity(Entity entity, JsonObject jsonObject) { + if (jsonObject.has("velocity")) { + double velocity = jsonObject.getAsJsonPrimitive("velocity").getAsDouble(); + entity.setVelocity(entity.getVelocity().multiply(velocity)); + } + } + + public static void setGlowing(Entity entity, JsonObject jsonObject) { + if (jsonObject.has("glowing")) { + boolean incendiary = jsonObject.getAsJsonPrimitive("glowing").getAsBoolean(); + entity.setGlowing(incendiary); + } + } + + public static void setGravity(Entity entity, JsonObject jsonObject) { + if (jsonObject.has("gravity")) { + boolean incendiary = jsonObject.getAsJsonPrimitive("gravity").getAsBoolean(); + entity.setGravity(incendiary); + } + } + + public static void setYield(Explosive explosive, JsonObject jsonObject) { + if (jsonObject.has("yield")) { + float yield = jsonObject.getAsJsonPrimitive("yield").getAsFloat(); + explosive.setYield(yield); + } + } + + public static void setIncendiary(Explosive explosive, JsonObject jsonObject) { + if (jsonObject.has("incendiary")) { + boolean incendiary = jsonObject.getAsJsonPrimitive("incendiary").getAsBoolean(); + explosive.setIsIncendiary(incendiary); + } + } + + public static void setBounce(Projectile projectile, JsonObject jsonObject) { + if (jsonObject.has("bounce")) { + boolean bounce = jsonObject.getAsJsonPrimitive("bounce").getAsBoolean(); + projectile.setBounce(bounce); + } + } + + public static void setFuseTime(TNTPrimed tntPrimed, JsonObject jsonObject) { + if (jsonObject.has("fuse")) { + int fuseTime = jsonObject.getAsJsonPrimitive("fuse").getAsInt(); + tntPrimed.setFuseTicks(fuseTime); + } + } + +}