feedc0de/LogBlock
1
0
Fork 0
forked from LogBlock/LogBlock
Code Pull Requests Activity

Compare commits

base: feedc0de:add_postgres_support
Branches Tags
feedc0de:add_postgres_support feedc0de:master feedc0de:version/1.16 feedc0de:inventory-logging feedc0de:worldedit-7.3 feedc0de:version/1.14 feedc0de:version/1.13.2 feedc0de:version/1.12 feedc0de:gh-pages
feedc0de:v1.13.1-SNAPSHOT-2 feedc0de:v1.13.1-SNAPSHOT-1 feedc0de:v1.12 feedc0de:v1.13-SNAPSHOT-1 feedc0de:v1.94 LogBlock:v1.12 LogBlock:v1.13-SNAPSHOT-1 LogBlock:v1.13.1-SNAPSHOT-1 LogBlock:v1.13.1-SNAPSHOT-2 LogBlock:v1.94
..
compare: feedc0de:inventory-logging
Branches Tags
feedc0de:add_postgres_support feedc0de:master feedc0de:version/1.16 feedc0de:inventory-logging feedc0de:worldedit-7.3 feedc0de:version/1.14 feedc0de:version/1.13.2 feedc0de:version/1.12 feedc0de:gh-pages LogBlock:master LogBlock:version/1.16 LogBlock:inventory-logging LogBlock:worldedit-7.3 LogBlock:version/1.14 LogBlock:version/1.13.2 LogBlock:version/1.12 LogBlock:gh-pages
feedc0de:v1.13.1-SNAPSHOT-2 feedc0de:v1.13.1-SNAPSHOT-1 feedc0de:v1.12 feedc0de:v1.13-SNAPSHOT-1 feedc0de:v1.94 LogBlock:v1.12 LogBlock:v1.13-SNAPSHOT-1 LogBlock:v1.13.1-SNAPSHOT-1 LogBlock:v1.13.1-SNAPSHOT-2 LogBlock:v1.94

1 Commits
add_postgr ... inventory-

Author SHA1 Message Date
Brokkonaut
1482b2c4fe Merge branch 'master' into inventory-logging 2021-04-25 01:59:46 +02:00
88 changed files with 7518 additions and 8573 deletions
Expand all files Collapse all files

14
.editorconfig
View File

@ -1,14 +0,0 @@
root = true
[*]
charset = utf-8
insert_final_newline = true
trim_trailing_whitespace = true
[*.java]
indent_style = space
indent_size = 4
[*.yml]
indent_style = space
indent_size = 2

11
.gitattributes vendored
View File

@ -1,11 +0,0 @@
# Set the default behavior, in case people don't have core.autocrlf set.
* text=auto
# Explicitly declare text files you want to always be normalized and converted
# to native line endings on checkout.
*.java text
*.txt text
*.yml text
*.xml text
*.md text
LICENSE text

47
pom.xml
View File

@ -1,10 +1,10 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.diddiz</groupId>
<artifactId>logblock</artifactId>
<version>1.20.0.0-SNAPSHOT</version>
<version>1.16.5.2-SNAPSHOT</version>
<packaging>jar</packaging>
<name>LogBlock</name>
@ -29,14 +29,12 @@
<distributionManagement>
<repository>
<id>nexus</id>
<name>Releases</name>
<url>https://www.iani.de/nexus/content/repositories/releases/</url>
<id>md_5-releases</id>
<url>https://repo.md-5.net/content/repositories/releases/</url>
</repository>
<snapshotRepository>
<id>nexus</id>
<name>Snapshot</name>
<url>https://www.iani.de/nexus/content/repositories/snapshots/</url>
<id>md_5-snapshots</id>
<url>https://repo.md-5.net/content/repositories/snapshots/</url>
</snapshotRepository>
</distributionManagement>
@ -44,31 +42,31 @@
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.20.4-R0.1-SNAPSHOT</version>
<version>1.16.1-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.sk89q.worldedit</groupId>
<artifactId>worldedit-bukkit</artifactId>
<version>7.3.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.sk89q.worldguard</groupId>
<artifactId>worldguard-bukkit</artifactId>
<version>7.1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>5.1.0</version>
<version>3.4.1</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-jdk14</artifactId>
<version>1.7.25</version>
<scope>compile</scope>
</dependency>
</dependencies>
@ -79,7 +77,7 @@
</repository>
<repository>
<id>sk89q-repo</id>
<url>https://maven.enginehub.org/repo/</url>
<url>https://maven.sk89q.com/repo/</url>
</repository>
<repository>
<id>brokkonaut-repo</id>
@ -125,15 +123,16 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.12.1</version>
<version>3.7.0</version>
<configuration>
<release>17</release>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>3.5.0</version>
<version>3.0.0</version>
<executions>
<execution>
<id>regex-property</id>
@ -153,7 +152,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.1</version>
<version>3.1.1</version>
<configuration>
</configuration>
<executions>
@ -168,6 +167,10 @@
<pattern>com.zaxxer.hikari</pattern>
<shadedPattern>de.diddiz.lib.com.zaxxer.hikari</shadedPattern>
</relocation>
<relocation>
<pattern>org.slf4j</pattern>
<shadedPattern>de.diddiz.lib.org.slf4j</shadedPattern>
</relocation>
</relocations>
</configuration>
</execution>

340
src/main/java/de/diddiz/LogBlock/Actor.java
View File

@ -1,182 +1,158 @@
package de.diddiz.LogBlock;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.projectiles.BlockProjectileSource;
import org.bukkit.projectiles.ProjectileSource;
import static de.diddiz.LogBlock.util.BukkitUtils.entityName;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.block.Block;
public class Actor {
@Override
public int hashCode() {
return this.UUID != null ? this.UUID.hashCode() : 0;
}
@Override
public boolean equals(Object obj) {
if (obj == null || getClass() != obj.getClass()) {
return false;
}
final Actor other = (Actor) obj;
return (this.UUID == null) ? (other.UUID == null) : this.UUID.equals(other.UUID);
}
final String name;
final String UUID;
final Location blockLocation;
final Entity entity;
public Actor(String name, String UUID) {
this.name = name;
this.UUID = UUID == null ? "unknown" : (UUID.length() > 36 ? UUID.substring(0, 36) : UUID);
this.blockLocation = null;
this.entity = null;
}
public Actor(String name, String UUID, Block block) {
this.name = name;
this.UUID = UUID == null ? "unknown" : (UUID.length() > 36 ? UUID.substring(0, 36) : UUID);
this.blockLocation = block == null ? null : block.getLocation();
this.entity = null;
}
public Actor(String name, java.util.UUID UUID) {
this.name = name;
this.UUID = UUID.toString();
this.blockLocation = null;
this.entity = null;
}
public Actor(String name, java.util.UUID UUID, Block block) {
this.name = name;
this.UUID = UUID.toString();
this.blockLocation = block == null ? null : block.getLocation();
this.entity = null;
}
public Actor(String name, java.util.UUID UUID, Entity entity) {
this.name = name;
this.UUID = UUID.toString();
this.blockLocation = null;
this.entity = entity;
}
public Actor(String name) {
this(name, generateUUID(name));
}
public Actor(String name, Block block) {
this(name, generateUUID(name), block);
}
public Actor(String name, Entity entity) {
this.name = name;
this.UUID = generateUUID(name);
this.blockLocation = null;
this.entity = entity;
}
public Actor(ResultSet rs) throws SQLException {
this(rs.getString("playername"), rs.getString("UUID"));
}
public String getName() {
return name;
}
public String getUUID() {
return UUID;
}
public Location getBlockLocation() {
return blockLocation;
}
/**
* The acting entity object (if known)
*/
public Entity getEntity() {
return entity;
}
public static Actor actorFromEntity(Entity entity) {
if (entity instanceof Player) {
return new Actor(entityName(entity), entity.getUniqueId(), entity);
}
if (entity instanceof Projectile) {
ProjectileSource shooter = ((Projectile) entity).getShooter();
if (shooter != null) {
return actorFromProjectileSource(shooter);
}
}
return new Actor(entityName(entity), entity);
}
@Deprecated
public static Actor actorFromEntity(EntityType entity) {
return new Actor(entity.name());
}
public static Actor actorFromProjectileSource(ProjectileSource psource) {
if (psource instanceof Entity) {
return actorFromEntity((Entity) psource);
}
if (psource instanceof BlockProjectileSource) {
return new Actor(((BlockProjectileSource) psource).getBlock().getType().toString());
} else {
return new Actor(psource.toString());
}
}
/**
* Generate an Actor object from a String name, trying to guess if it's an online player
* and if so, setting the UUID accordingly. This only checks against currently online
* players and is a "best effort" attempt for use with the pre-UUID API
* <p>
* If you know something is an entity (player or otherwise) use the {@link #actorFromEntity(org.bukkit.entity.Entity) }
* or {@link #actorFromEntity(org.bukkit.entity.EntityType) } methods
* <p>
* If you know something is a server effect (like gravity) use {@link #Actor(java.lang.String)}
*
* @deprecated Only use this if you have a String of unknown origin
*
* @param actorName
* String of unknown origin
* @return
*/
@Deprecated
public static Actor actorFromString(String actorName) {
Player p = Bukkit.getServer().getPlayerExact(actorName);
if (p != null) {
return actorFromEntity(p);
}
// No player found online with that name, assuming non-player entity/effect
return new Actor(actorName);
}
public static boolean isValidUUID(String uuid) {
try {
java.util.UUID.fromString(uuid);
return true;
} catch (IllegalArgumentException e) {
return false;
}
}
public static String generateUUID(String name) {
return "log_" + name;
}
}
package de.diddiz.LogBlock;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.projectiles.BlockProjectileSource;
import org.bukkit.projectiles.ProjectileSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import static de.diddiz.util.BukkitUtils.entityName;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.block.Block;
public class Actor {
@Override
public int hashCode() {
return this.UUID != null ? this.UUID.hashCode() : 0;
}
@Override
public boolean equals(Object obj) {
if (obj == null || getClass() != obj.getClass()) {
return false;
}
final Actor other = (Actor) obj;
return (this.UUID == null) ? (other.UUID == null) : this.UUID.equals(other.UUID);
}
final String name;
final String UUID;
final Location blockLocation;
public Actor(String name, String UUID) {
this.name = name;
this.UUID = UUID == null ? "unknown" : (UUID.length() > 36 ? UUID.substring(0, 36) : UUID);
this.blockLocation = null;
}
public Actor(String name, String UUID, Block block) {
this.name = name;
this.UUID = UUID == null ? "unknown" : (UUID.length() > 36 ? UUID.substring(0, 36) : UUID);
this.blockLocation = block == null ? null : block.getLocation();
}
public Actor(String name, java.util.UUID UUID) {
this.name = name;
this.UUID = UUID.toString();
this.blockLocation = null;
}
public Actor(String name, java.util.UUID UUID, Block block) {
this.name = name;
this.UUID = UUID.toString();
this.blockLocation = block == null ? null : block.getLocation();
}
public Actor(String name) {
this(name, generateUUID(name));
}
public Actor(String name, Block block) {
this(name, generateUUID(name), block);
}
public Actor(ResultSet rs) throws SQLException {
this(rs.getString("playername"), rs.getString("UUID"));
}
public String getName() {
return name;
}
public String getUUID() {
return UUID;
}
public Location getBlockLocation() {
return blockLocation;
}
public static Actor actorFromEntity(Entity entity) {
if (entity instanceof Player) {
return new Actor(entityName(entity), entity.getUniqueId());
}
if (entity instanceof Projectile) {
ProjectileSource shooter = ((Projectile) entity).getShooter();
if (shooter != null) {
return actorFromProjectileSource(shooter);
}
}
return new Actor(entityName(entity));
}
public static Actor actorFromEntity(EntityType entity) {
return new Actor(entity.name());
}
public static Actor actorFromProjectileSource(ProjectileSource psource) {
if (psource instanceof Entity) {
return actorFromEntity((Entity) psource);
}
if (psource instanceof BlockProjectileSource) {
return new Actor(((BlockProjectileSource) psource).getBlock().getType().toString());
} else {
return new Actor(psource.toString());
}
}
/**
* Generate an Actor object from a String name, trying to guess if it's an online player
* and if so, setting the UUID accordingly. This only checks against currently online
* players and is a "best effort" attempt for use with the pre-UUID API
* <p>
* If you know something is an entity (player or otherwise) use the {@link #actorFromEntity(org.bukkit.entity.Entity) }
* or {@link #actorFromEntity(org.bukkit.entity.EntityType) } methods
* <p>
* If you know something is a server effect (like gravity) use {@link #Actor(java.lang.String)}
*
* @deprecated Only use this if you have a String of unknown origin
*
* @param actorName
* String of unknown origin
* @return
*/
@Deprecated
public static Actor actorFromString(String actorName) {
Collection<? extends Player> players = Bukkit.getServer().getOnlinePlayers();
for (Player p : players) {
if (p.getName().equalsIgnoreCase(actorName)) {
return actorFromEntity(p);
}
}
// No player found online with that name, assuming non-player entity/effect
return new Actor(actorName);
}
public static boolean isValidUUID(String uuid) {
try {
java.util.UUID.fromString(uuid);
return true;
} catch (IllegalArgumentException e) {
return false;
}
}
public static String generateUUID(String name) {
return "log_" + name;
}
}

61
src/main/java/de/diddiz/LogBlock/AutoClearLog.java
View File

@ -1,32 +1,29 @@
package de.diddiz.LogBlock;
import java.util.Arrays;
import java.util.logging.Level;
import static de.diddiz.LogBlock.config.Config.autoClearLog;
import static org.bukkit.Bukkit.*;
public class AutoClearLog implements Runnable {
private final LogBlock logblock;
AutoClearLog(LogBlock logblock) {
this.logblock = logblock;
}
@Override
public void run() {
final CommandsHandler handler = logblock.getCommandsHandler();
for (final String paramStr : autoClearLog) {
if (!logblock.isCompletelyEnabled()) {
return; // do not try when plugin is disabled
}
try {
final QueryParams params = new QueryParams(logblock, getConsoleSender(), Arrays.asList(paramStr.split(" ")));
params.noForcedLimit = true;
handler.new CommandClearLog(getServer().getConsoleSender(), params, false);
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Failed to schedule auto ClearLog: ", ex);
}
}
}
}
package de.diddiz.LogBlock;
import java.util.Arrays;
import java.util.logging.Level;
import static de.diddiz.LogBlock.config.Config.autoClearLog;
import static org.bukkit.Bukkit.*;
public class AutoClearLog implements Runnable {
private final LogBlock logblock;
AutoClearLog(LogBlock logblock) {
this.logblock = logblock;
}
@Override
public void run() {
final CommandsHandler handler = logblock.getCommandsHandler();
for (final String paramStr : autoClearLog) {
try {
final QueryParams params = new QueryParams(logblock, getConsoleSender(), Arrays.asList(paramStr.split(" ")));
params.noForcedLimit = true;
handler.new CommandClearLog(getServer().getConsoleSender(), params, false);
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Failed to schedule auto ClearLog: ", ex);
}
}
}
}

525
src/main/java/de/diddiz/LogBlock/BlockChange.java
View File

@ -1,272 +1,253 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.ActionColor.CREATE;
import static de.diddiz.LogBlock.util.ActionColor.DESTROY;
import static de.diddiz.LogBlock.util.ActionColor.INTERACT;
import static de.diddiz.LogBlock.util.MessagingUtil.createTextComponentWithColor;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyDate;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyLocation;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyMaterial;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyState;
import static de.diddiz.LogBlock.util.TypeColor.DEFAULT;
import de.diddiz.LogBlock.blockstate.BlockStateCodecs;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.Utils;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Note;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Lightable;
import org.bukkit.block.data.Openable;
import org.bukkit.block.data.Powerable;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.block.data.type.Candle;
import org.bukkit.block.data.type.Comparator;
import org.bukkit.block.data.type.DaylightDetector;
import org.bukkit.block.data.type.Lectern;
import org.bukkit.block.data.type.NoteBlock;
import org.bukkit.block.data.type.Repeater;
import org.bukkit.block.data.type.Sign;
import org.bukkit.block.data.type.Switch;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.inventory.ItemStack;
public class BlockChange implements LookupCacheElement {
public final long id, date;
public final Location loc;
public final Actor actor;
public final String playerName;
public final int replacedMaterial, replacedData, typeMaterial, typeData;
public final byte[] replacedState, typeState;
public final ChestAccess ca;
public BlockChange(long date, Location loc, Actor actor, int replaced, int replacedData, byte[] replacedState, int type, int typeData, byte[] typeState, ChestAccess ca) {
id = 0;
this.date = date;
this.loc = loc;
this.actor = actor;
this.replacedMaterial = replaced;
this.replacedData = replacedData;
this.replacedState = replacedState;
this.typeMaterial = type;
this.typeData = typeData;
this.typeState = typeState;
this.ca = ca;
this.playerName = actor == null ? null : actor.getName();
}
public BlockChange(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getLong("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
loc = p.needCoords ? new Location(p.world, rs.getInt("x"), rs.getInt("y"), rs.getInt("z")) : null;
actor = p.needPlayer ? new Actor(rs) : null;
playerName = p.needPlayer ? rs.getString("playername") : null;
replacedMaterial = p.needType ? rs.getInt("replaced") : 0;
replacedData = p.needType ? rs.getInt("replacedData") : -1;
typeMaterial = p.needType ? rs.getInt("type") : 0;
typeData = p.needType ? rs.getInt("typeData") : -1;
replacedState = p.needType ? rs.getBytes("replacedState") : null;
typeState = p.needType ? rs.getBytes("typeState") : null;
ChestAccess catemp = null;
if (p.needChestAccess) {
ItemStack stack = Utils.loadItemStack(rs.getBytes("item"));
if (stack != null) {
catemp = new ChestAccess(stack, rs.getBoolean("itemremove"), rs.getInt("itemtype"));
}
}
ca = catemp;
}
private BaseComponent getTypeDetails(BlockData type, byte[] typeState) {
return getTypeDetails(type, typeState, null, null);
}
private BaseComponent getTypeDetails(BlockData type, byte[] typeState, BlockData oldType, byte[] oldTypeState) {
BaseComponent typeDetails = null;
if (BlockStateCodecs.hasCodec(type.getMaterial())) {
try {
typeDetails = BlockStateCodecs.getChangesAsComponent(type.getMaterial(), Utils.deserializeYamlConfiguration(typeState), type.equals(oldType) ? Utils.deserializeYamlConfiguration(oldTypeState) : null);
} catch (Exception e) {
LogBlock.getInstance().getLogger().log(Level.SEVERE, "Could not parse BlockState for " + type.getMaterial(), e);
}
}
if (typeDetails == null) {
return new TextComponent("");
} else {
TextComponent component = new TextComponent(" ");
component.addExtra(typeDetails);
return component;
}
}
@Override
public String toString() {
return BaseComponent.toPlainText(getLogMessage(-1));
}
@Override
public BaseComponent[] getLogMessage(int entry) {
TextComponent msg = new TextComponent();
if (date > 0) {
msg.addExtra(prettyDate(date));
msg.addExtra(" ");
}
if (actor != null) {
msg.addExtra(actor.getName());
msg.addExtra(" ");
}
BlockData type = getBlockSet();
BlockData replaced = getBlockReplaced();
if (type == null || replaced == null) {
msg.addExtra("did an unknown block modification");
return new BaseComponent[] { msg };
}
// Process type details once for later use.
BaseComponent typeDetails = getTypeDetails(type, typeState, replaced, replacedState);
BaseComponent replacedDetails = getTypeDetails(replaced, replacedState);
if (type.getMaterial().equals(replaced.getMaterial()) || (type.getMaterial() == Material.CAKE && BukkitUtils.isCandleCake(replaced.getMaterial()))) {
if (BukkitUtils.isEmpty(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("did an unspecified action", INTERACT.getColor()));
} else if (ca != null) {
if (ca.itemStack == null) {
msg.addExtra(createTextComponentWithColor("looked inside ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (ca.remove) {
msg.addExtra(createTextComponentWithColor("took ", DESTROY.getColor()));
msg.addExtra(BukkitUtils.toString(ca.itemStack));
msg.addExtra(createTextComponentWithColor(" from ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
} else {
msg.addExtra(createTextComponentWithColor("put ", CREATE.getColor()));
msg.addExtra(BukkitUtils.toString(ca.itemStack));
msg.addExtra(createTextComponentWithColor(" into ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
}
} else if (type instanceof Waterlogged && ((Waterlogged) type).isWaterlogged() != ((Waterlogged) replaced).isWaterlogged()) {
if (((Waterlogged) type).isWaterlogged()) {
msg.addExtra(createTextComponentWithColor("waterlogged ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
} else {
msg.addExtra(createTextComponentWithColor("dried ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
}
} else if (BukkitUtils.isContainerBlock(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("opened ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type instanceof Openable && ((Openable) type).isOpen() != ((Openable) replaced).isOpen()) {
// Door, Trapdoor, Fence gate
msg.addExtra(createTextComponentWithColor(((Openable) type).isOpen() ? "opened " : "closed ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.LEVER && ((Switch) type).isPowered() != ((Switch) replaced).isPowered()) {
msg.addExtra(createTextComponentWithColor("switched ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(((Switch) type).isPowered() ? " on" : " off"));
} else if (type instanceof Switch && ((Switch) type).isPowered() != ((Switch) replaced).isPowered()) {
msg.addExtra(createTextComponentWithColor("pressed ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.CAKE) {
msg.addExtra(createTextComponentWithColor("ate a piece of ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.NOTE_BLOCK) {
Note note = ((NoteBlock) type).getNote();
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(note.getTone().name() + (note.isSharped() ? "#" : "")));
} else if (type.getMaterial() == Material.REPEATER) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((Repeater) type).getDelay()));
msg.addExtra(createTextComponentWithColor(" ticks delay", DEFAULT.getColor()));
} else if (type.getMaterial() == Material.COMPARATOR) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((Comparator) type).getMode()));
} else if (type.getMaterial() == Material.DAYLIGHT_DETECTOR) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((DaylightDetector) type).isInverted() ? "inverted" : "normal"));
} else if (type instanceof Lectern) {
msg.addExtra(createTextComponentWithColor("changed the book on a ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to");
msg.addExtra(prettyState(typeDetails));
} else if (type instanceof Powerable) {
msg.addExtra(createTextComponentWithColor("stepped on ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.TRIPWIRE) {
msg.addExtra(createTextComponentWithColor("ran into ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type instanceof Sign || type instanceof WallSign) {
msg.addExtra(createTextComponentWithColor("edited a ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(createTextComponentWithColor(" to", CREATE.getColor()));
msg.addExtra(prettyState(typeDetails));
} else if (type instanceof Candle && ((Candle) type).getCandles() != ((Candle) replaced).getCandles()) {
msg.addExtra(createTextComponentWithColor("added a candle to ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
} else if ((type instanceof Candle || BukkitUtils.isCandleCake(type.getMaterial())) && ((Lightable) type).isLit() != ((Lightable) replaced).isLit()) {
if (((Lightable) type).isLit()) {
msg.addExtra(createTextComponentWithColor("lit a ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
} else {
msg.addExtra(createTextComponentWithColor("extinguished a ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
}
} else {
msg.addExtra(createTextComponentWithColor("replaced ", CREATE.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
msg.addExtra(createTextComponentWithColor(" with ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
}
} else if (BukkitUtils.isEmpty(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("destroyed ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
} else if (BukkitUtils.isEmpty(replaced.getMaterial())) {
msg.addExtra(createTextComponentWithColor("created ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
} else {
msg.addExtra(createTextComponentWithColor("replaced ", CREATE.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
msg.addExtra(createTextComponentWithColor(" with ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
}
if (loc != null) {
msg.addExtra(" at ");
msg.addExtra(prettyLocation(loc, entry));
}
return new BaseComponent[] { msg };
}
public BlockData getBlockReplaced() {
return MaterialConverter.getBlockData(replacedMaterial, replacedData);
}
public BlockData getBlockSet() {
return MaterialConverter.getBlockData(typeMaterial, typeData);
}
@Override
public Location getLocation() {
return loc;
}
}
package de.diddiz.LogBlock;
import static de.diddiz.util.ActionColor.CREATE;
import static de.diddiz.util.ActionColor.DESTROY;
import static de.diddiz.util.ActionColor.INTERACT;
import static de.diddiz.util.TypeColor.DEFAULT;
import static de.diddiz.util.MessagingUtil.createTextComponentWithColor;
import static de.diddiz.util.MessagingUtil.prettyDate;
import static de.diddiz.util.MessagingUtil.prettyLocation;
import static de.diddiz.util.MessagingUtil.prettyMaterial;
import static de.diddiz.util.MessagingUtil.prettyState;
import de.diddiz.LogBlock.blockstate.BlockStateCodecs;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.Utils;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Note;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Openable;
import org.bukkit.block.data.Powerable;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.block.data.type.Comparator;
import org.bukkit.block.data.type.DaylightDetector;
import org.bukkit.block.data.type.Lectern;
import org.bukkit.block.data.type.NoteBlock;
import org.bukkit.block.data.type.Repeater;
import org.bukkit.block.data.type.Sign;
import org.bukkit.block.data.type.Switch;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.inventory.ItemStack;
public class BlockChange implements LookupCacheElement {
public final long id, date;
public final Location loc;
public final Actor actor;
public final String playerName;
public final int replacedMaterial, replacedData, typeMaterial, typeData;
public final byte[] replacedState, typeState;
public final ChestAccess ca;
public BlockChange(long date, Location loc, Actor actor, int replaced, int replacedData, byte[] replacedState, int type, int typeData, byte[] typeState, ChestAccess ca) {
id = 0;
this.date = date;
this.loc = loc;
this.actor = actor;
this.replacedMaterial = replaced;
this.replacedData = replacedData;
this.replacedState = replacedState;
this.typeMaterial = type;
this.typeData = typeData;
this.typeState = typeState;
this.ca = ca;
this.playerName = actor == null ? null : actor.getName();
}
public BlockChange(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getInt("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
loc = p.needCoords ? new Location(p.world, rs.getInt("x"), rs.getInt("y"), rs.getInt("z")) : null;
actor = p.needPlayer ? new Actor(rs) : null;
playerName = p.needPlayer ? rs.getString("playername") : null;
replacedMaterial = p.needType ? rs.getInt("replaced") : 0;
replacedData = p.needType ? rs.getInt("replacedData") : -1;
typeMaterial = p.needType ? rs.getInt("type") : 0;
typeData = p.needType ? rs.getInt("typeData") : -1;
replacedState = p.needType ? rs.getBytes("replacedState") : null;
typeState = p.needType ? rs.getBytes("typeState") : null;
ChestAccess catemp = null;
if (p.needChestAccess) {
ItemStack stack = Utils.loadItemStack(rs.getBytes("item"));
if (stack != null) {
catemp = new ChestAccess(stack, rs.getBoolean("itemremove"), rs.getInt("itemtype"));
}
}
ca = catemp;
}
private String getTypeDetails(BlockData type, byte[] typeState) {
String typeDetails = null;
if (BlockStateCodecs.hasCodec(type.getMaterial())) {
try {
typeDetails = BlockStateCodecs.toString(type.getMaterial(), Utils.deserializeYamlConfiguration(typeState));
} catch (Exception e) {
LogBlock.getInstance().getLogger().log(Level.SEVERE, "Could not parse BlockState for " + type.getMaterial(), e);
}
}
if (typeDetails == null) {
return "";
} else {
return " " + typeDetails;
}
}
@Override
public String toString() {
return BaseComponent.toPlainText(getLogMessage(-1));
}
@Override
public BaseComponent[] getLogMessage(int entry) {
TextComponent msg = new TextComponent();
if (date > 0) {
msg.addExtra(prettyDate(date));
msg.addExtra(" ");
}
if (actor != null) {
msg.addExtra(actor.getName());
msg.addExtra(" ");
}
BlockData type = getBlockSet();
BlockData replaced = getBlockReplaced();
if (type == null || replaced == null) {
msg.addExtra("did an unknown block modification");
return new BaseComponent[] { msg };
}
// Process type details once for later use.
String typeDetails = getTypeDetails(type, typeState);
String replacedDetails = getTypeDetails(replaced, replacedState);
if (type.getMaterial().equals(replaced.getMaterial())) {
if (BukkitUtils.isEmpty(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("did an unspecified action", INTERACT.getColor()));
} else if (ca != null) {
if (ca.itemStack == null) {
msg.addExtra(createTextComponentWithColor("looked inside ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (ca.remove) {
msg.addExtra(createTextComponentWithColor("took ", DESTROY.getColor()));
msg.addExtra(BukkitUtils.toString(ca.itemStack));
msg.addExtra(createTextComponentWithColor(" from ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
} else {
msg.addExtra(createTextComponentWithColor("put ", CREATE.getColor()));
msg.addExtra(BukkitUtils.toString(ca.itemStack));
msg.addExtra(createTextComponentWithColor(" into ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
}
} else if (type instanceof Waterlogged && ((Waterlogged) type).isWaterlogged() != ((Waterlogged) replaced).isWaterlogged()) {
if (((Waterlogged) type).isWaterlogged()) {
msg.addExtra(createTextComponentWithColor("waterlogged ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
} else {
msg.addExtra(createTextComponentWithColor("dried ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
}
} else if (BukkitUtils.getContainerBlocks().contains(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("opened ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type instanceof Openable && ((Openable) type).isOpen() != ((Openable) replaced).isOpen()) {
// Door, Trapdoor, Fence gate
msg.addExtra(createTextComponentWithColor(((Openable) type).isOpen() ? "opened " : "closed ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.LEVER && ((Switch) type).isPowered() != ((Switch) replaced).isPowered()) {
msg.addExtra(createTextComponentWithColor("switched ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(((Switch) type).isPowered() ? " on" : " off"));
} else if (type instanceof Switch && ((Switch) type).isPowered() != ((Switch) replaced).isPowered()) {
msg.addExtra(createTextComponentWithColor("pressed ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.CAKE) {
msg.addExtra(createTextComponentWithColor("ate a piece of ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.NOTE_BLOCK) {
Note note = ((NoteBlock) type).getNote();
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(note.getTone().name() + (note.isSharped() ? "#" : "")));
} else if (type.getMaterial() == Material.REPEATER) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((Repeater) type).getDelay()));
msg.addExtra(createTextComponentWithColor(" ticks delay", DEFAULT.getColor()));
} else if (type.getMaterial() == Material.COMPARATOR) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((Comparator) type).getMode()));
} else if (type.getMaterial() == Material.DAYLIGHT_DETECTOR) {
msg.addExtra(createTextComponentWithColor("set ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to ");
msg.addExtra(prettyState(((DaylightDetector) type).isInverted() ? "inverted" : "normal"));
} else if (type instanceof Lectern) {
msg.addExtra(createTextComponentWithColor("changed the book on a ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(" to");
msg.addExtra(prettyState(typeDetails.length() == 0 ? " empty" : typeDetails));
} else if (type instanceof Powerable) {
msg.addExtra(createTextComponentWithColor("stepped on ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type.getMaterial() == Material.TRIPWIRE) {
msg.addExtra(createTextComponentWithColor("ran into ", INTERACT.getColor()));
msg.addExtra(prettyMaterial(type));
} else if (type instanceof Sign || type instanceof WallSign) {
msg.addExtra(createTextComponentWithColor("edited a ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(createTextComponentWithColor(" to ", CREATE.getColor()));
msg.addExtra(prettyState(typeDetails));
} else {
msg.addExtra(createTextComponentWithColor("replaced ", CREATE.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
msg.addExtra(createTextComponentWithColor(" with ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
}
} else if (BukkitUtils.isEmpty(type.getMaterial())) {
msg.addExtra(createTextComponentWithColor("destroyed ", DESTROY.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
} else if (BukkitUtils.isEmpty(replaced.getMaterial())) {
msg.addExtra(createTextComponentWithColor("created ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
} else {
msg.addExtra(createTextComponentWithColor("replaced ", CREATE.getColor()));
msg.addExtra(prettyMaterial(replaced));
msg.addExtra(prettyState(replacedDetails));
msg.addExtra(createTextComponentWithColor(" with ", CREATE.getColor()));
msg.addExtra(prettyMaterial(type));
msg.addExtra(prettyState(typeDetails));
}
if (loc != null) {
msg.addExtra(" at ");
msg.addExtra(prettyLocation(loc, entry));
}
return new BaseComponent[] { msg };
}
public BlockData getBlockReplaced() {
return MaterialConverter.getBlockData(replacedMaterial, replacedData);
}
public BlockData getBlockSet() {
return MaterialConverter.getBlockData(typeMaterial, typeData);
}
@Override
public Location getLocation() {
return loc;
}
}

118
src/main/java/de/diddiz/LogBlock/ChatMessage.java
View File

@ -1,59 +1,59 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.LoggingUtil.checkText;
import static de.diddiz.LogBlock.util.MessagingUtil.brackets;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyDate;
import de.diddiz.LogBlock.util.MessagingUtil;
import de.diddiz.LogBlock.util.MessagingUtil.BracketType;
import java.sql.ResultSet;
import java.sql.SQLException;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
public class ChatMessage implements LookupCacheElement {
final long id, date;
final String playerName, message;
final Actor player;
public ChatMessage(Actor player, String message) {
id = 0;
date = System.currentTimeMillis() / 1000;
this.player = player;
this.message = checkText(message);
this.playerName = player == null ? null : player.getName();
}
public ChatMessage(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getLong("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
player = p.needPlayer ? new Actor(rs) : null;
playerName = p.needPlayer ? rs.getString("playername") : null;
message = p.needMessage ? rs.getString("message") : null;
}
@Override
public Location getLocation() {
return null;
}
@Override
public BaseComponent[] getLogMessage(int entry) {
TextComponent msg = new TextComponent();
if (date > 0) {
msg.addExtra(prettyDate(date));
msg.addExtra(" ");
}
if (playerName != null) {
msg.addExtra(brackets(BracketType.ANGLE, MessagingUtil.createTextComponentWithColor(playerName, net.md_5.bungee.api.ChatColor.WHITE)));
msg.addExtra(" ");
}
if (message != null) {
for (BaseComponent messageComponent : TextComponent.fromLegacyText(message)) {
msg.addExtra(messageComponent);
}
}
return new BaseComponent[] { msg };
}
}
package de.diddiz.LogBlock;
import static de.diddiz.util.LoggingUtil.checkText;
import static de.diddiz.util.MessagingUtil.brackets;
import static de.diddiz.util.MessagingUtil.prettyDate;
import de.diddiz.util.MessagingUtil;
import de.diddiz.util.MessagingUtil.BracketType;
import java.sql.ResultSet;
import java.sql.SQLException;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
public class ChatMessage implements LookupCacheElement {
final long id, date;
final String playerName, message;
final Actor player;
public ChatMessage(Actor player, String message) {
id = 0;
date = System.currentTimeMillis() / 1000;
this.player = player;
this.message = checkText(message);
this.playerName = player == null ? null : player.getName();
}
public ChatMessage(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getInt("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
player = p.needPlayer ? new Actor(rs) : null;
playerName = p.needPlayer ? rs.getString("playername") : null;
message = p.needMessage ? rs.getString("message") : null;
}
@Override
public Location getLocation() {
return null;
}
@Override
public BaseComponent[] getLogMessage(int entry) {
TextComponent msg = new TextComponent();
if (date > 0) {
msg.addExtra(prettyDate(date));
msg.addExtra(" ");
}
if (playerName != null) {
msg.addExtra(brackets(BracketType.ANGLE, MessagingUtil.createTextComponentWithColor(playerName, net.md_5.bungee.api.ChatColor.WHITE)));
msg.addExtra(" ");
}
if (message != null) {
for (BaseComponent messageComponent : TextComponent.fromLegacyText(message)) {
msg.addExtra(messageComponent);
}
}
return new BaseComponent[] { msg };
}
}

30
src/main/java/de/diddiz/LogBlock/ChestAccess.java
View File

@ -1,15 +1,15 @@
package de.diddiz.LogBlock;
import org.bukkit.inventory.ItemStack;
public class ChestAccess {
public final ItemStack itemStack;
public final boolean remove;
public final int itemType;
public ChestAccess(ItemStack itemStack, boolean remove, int itemType) {
this.itemStack = itemStack;
this.remove = remove;
this.itemType = itemType;
}
}
package de.diddiz.LogBlock;
import org.bukkit.inventory.ItemStack;
public class ChestAccess {
public final ItemStack itemStack;
public final boolean remove;
public final int itemType;
public ChestAccess(ItemStack itemStack, boolean remove, int itemType) {
this.itemStack = itemStack;
this.remove = remove;
this.itemType = itemType;
}
}

147
src/main/java/de/diddiz/LogBlock/CommandsHandler.java
View File

@ -14,21 +14,20 @@ import static de.diddiz.LogBlock.config.Config.rollbackMaxArea;
import static de.diddiz.LogBlock.config.Config.rollbackMaxTime;
import static de.diddiz.LogBlock.config.Config.toolsByName;
import static de.diddiz.LogBlock.config.Config.toolsByType;
import static de.diddiz.LogBlock.util.BukkitUtils.giveTool;
import static de.diddiz.LogBlock.util.BukkitUtils.safeSpawnHeight;
import static de.diddiz.LogBlock.util.TypeColor.DEFAULT;
import static de.diddiz.LogBlock.util.TypeColor.ERROR;
import static de.diddiz.LogBlock.util.TypeColor.HEADER;
import static de.diddiz.LogBlock.util.Utils.isInt;
import static de.diddiz.LogBlock.util.Utils.listing;
import static de.diddiz.util.BukkitUtils.giveTool;
import static de.diddiz.util.BukkitUtils.saveSpawnHeight;
import static de.diddiz.util.TypeColor.DEFAULT;
import static de.diddiz.util.TypeColor.ERROR;
import static de.diddiz.util.TypeColor.HEADER;
import static de.diddiz.util.Utils.isInt;
import static de.diddiz.util.Utils.listing;
import de.diddiz.LogBlock.QueryParams.BlockChangeType;
import de.diddiz.LogBlock.QueryParams.Order;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.MessagingUtil;
import de.diddiz.LogBlock.util.Utils;
import de.diddiz.util.Utils;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
@ -45,10 +44,8 @@ import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ClickEvent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.command.Command;
@ -71,75 +68,53 @@ public class CommandsHandler implements CommandExecutor {
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
try {
if (args.length == 0) {
sender.sendMessage(ChatColor.YELLOW + "------------------[ " + ChatColor.WHITE + "LogBlock" + ChatColor.YELLOW + " ]-------------------");
sender.sendMessage(ChatColor.GOLD + "LogBlock " + ChatColor.WHITE + "v" + logblock.getDescription().getVersion() + ChatColor.GOLD + " by DiddiZ");
TextComponent message = MessagingUtil.createTextComponentWithColor("Type ", net.md_5.bungee.api.ChatColor.GOLD);
TextComponent clickable = MessagingUtil.createTextComponentWithColor("/lb help", net.md_5.bungee.api.ChatColor.WHITE);
clickable.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/lb help"));
message.addExtra(clickable);
message.addExtra(" for help");
sender.spigot().sendMessage(message);
sender.sendMessage(ChatColor.LIGHT_PURPLE + "LogBlock v" + logblock.getDescription().getVersion() + " by DiddiZ");
sender.sendMessage(ChatColor.LIGHT_PURPLE + "Type /lb help for help");
} else {
final String command = args[0].toLowerCase();
if (command.equals("help")) {
sender.sendMessage(ChatColor.YELLOW + "----------------[ " + ChatColor.WHITE + "LogBlock Help" + ChatColor.YELLOW + " ]----------------");
TextComponent message = MessagingUtil.createTextComponentWithColor("For the commands list type ", net.md_5.bungee.api.ChatColor.GOLD);
TextComponent clickable = MessagingUtil.createTextComponentWithColor("/lb commands", net.md_5.bungee.api.ChatColor.WHITE);
clickable.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/lb commands"));
message.addExtra(clickable);
sender.spigot().sendMessage(message);
message = MessagingUtil.createTextComponentWithColor("For the parameters list type ", net.md_5.bungee.api.ChatColor.GOLD);
clickable = MessagingUtil.createTextComponentWithColor("/lb params", net.md_5.bungee.api.ChatColor.WHITE);
clickable.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/lb params"));
message.addExtra(clickable);
sender.spigot().sendMessage(message);
message = MessagingUtil.createTextComponentWithColor("For the list of permissions you got type ", net.md_5.bungee.api.ChatColor.GOLD);
clickable = MessagingUtil.createTextComponentWithColor("/lb permissions", net.md_5.bungee.api.ChatColor.WHITE);
clickable.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/lb permissions"));
message.addExtra(clickable);
sender.spigot().sendMessage(message);
sender.sendMessage(ChatColor.DARK_AQUA + "LogBlock Help:");
sender.sendMessage(ChatColor.GOLD + "For the commands list type '/lb commands'");
sender.sendMessage(ChatColor.GOLD + "For the parameters list type '/lb params'");
sender.sendMessage(ChatColor.GOLD + "For the list of permissions you got type '/lb permissions'");
} else if (command.equals("commands")) {
sender.sendMessage(ChatColor.YELLOW + "--------------[ " + ChatColor.WHITE + "LogBlock Commands" + ChatColor.YELLOW + " ]--------------");
sender.sendMessage(ChatColor.GOLD + "/lb tool " + ChatColor.WHITE + "-- Gives you the lb tool");
sender.sendMessage(ChatColor.GOLD + "/lb tool [on|off] " + ChatColor.WHITE + "-- Enables/Disables tool");
sender.sendMessage(ChatColor.GOLD + "/lb tool [params] " + ChatColor.WHITE + "-- Sets the tool lookup query");
sender.sendMessage(ChatColor.GOLD + "/lb tool default " + ChatColor.WHITE + "-- Sets the tool lookup query to default");
sender.sendMessage(ChatColor.GOLD + "/lb toolblock " + ChatColor.WHITE + "-- Analog to tool");
sender.sendMessage(ChatColor.GOLD + "/lb hide " + ChatColor.WHITE + "-- Hides you from log");
sender.sendMessage(ChatColor.GOLD + "/lb rollback [params] " + ChatColor.WHITE + "-- Rollback");
sender.sendMessage(ChatColor.GOLD + "/lb redo [params] " + ChatColor.WHITE + "-- Redo");
sender.sendMessage(ChatColor.GOLD + "/lb tp [params] " + ChatColor.WHITE + "-- Teleports you to the location of griefing");
sender.sendMessage(ChatColor.GOLD + "/lb writelogfile [params] " + ChatColor.WHITE + "-- Writes a log file");
sender.sendMessage(ChatColor.GOLD + "/lb lookup [params] " + ChatColor.WHITE + "-- Lookup");
sender.sendMessage(ChatColor.GOLD + "/lb prev|next " + ChatColor.WHITE + "-- Browse lookup result pages");
sender.sendMessage(ChatColor.GOLD + "/lb page " + ChatColor.WHITE + "-- Shows a specific lookup result page");
sender.sendMessage(ChatColor.GOLD + "/lb me " + ChatColor.WHITE + "-- Displays your stats");
sender.sendMessage("");
sender.sendMessage(ChatColor.GOLD + "Look at " + ChatColor.WHITE + "github.com/LogBlock/LogBlock/wiki/Commands" + ChatColor.GOLD + " for the full commands reference");
sender.sendMessage(ChatColor.DARK_AQUA + "LogBlock Commands:");
sender.sendMessage(ChatColor.GOLD + "/lb tool -- Gives you the lb tool");
sender.sendMessage(ChatColor.GOLD + "/lb tool [on|off] -- Enables/Disables tool");
sender.sendMessage(ChatColor.GOLD + "/lb tool [params] -- Sets the tool lookup query");
sender.sendMessage(ChatColor.GOLD + "/lb tool default -- Sets the tool lookup query to default");
sender.sendMessage(ChatColor.GOLD + "/lb toolblock -- Analog to tool");
sender.sendMessage(ChatColor.GOLD + "/lb hide -- Hides you from log");
sender.sendMessage(ChatColor.GOLD + "/lb rollback [params] -- Rollback");
sender.sendMessage(ChatColor.GOLD + "/lb redo [params] -- Redo");
sender.sendMessage(ChatColor.GOLD + "/lb tp [params] -- Teleports you to the location of griefing");
sender.sendMessage(ChatColor.GOLD + "/lb writelogfile [params] -- Writes a log file");
sender.sendMessage(ChatColor.GOLD + "/lb lookup [params] -- Lookup");
sender.sendMessage(ChatColor.GOLD + "/lb prev|next -- Browse lookup result pages");
sender.sendMessage(ChatColor.GOLD + "/lb page -- Shows a specific lookup result page");
sender.sendMessage(ChatColor.GOLD + "/lb me -- Displays your stats");
sender.sendMessage(ChatColor.GOLD + "Look at github.com/LogBlock/LogBlock/wiki/Commands for the full commands reference");
} else if (command.equals("params")) {
sender.sendMessage(ChatColor.YELLOW + "----------[ " + ChatColor.WHITE + "LogBlock Query Parameters" + ChatColor.YELLOW + " ]----------");
sender.sendMessage(ChatColor.DARK_AQUA + "LogBlock Query Parameters:");
sender.sendMessage(ChatColor.GOLD + "Use doublequotes to escape a keyword: world \"world\"");
sender.sendMessage(ChatColor.GOLD + "player [name1] <name2> <name3> " + ChatColor.WHITE + "-- List of players");
sender.sendMessage(ChatColor.GOLD + "block [type1] <type2> <type3> " + ChatColor.WHITE + "-- List of block types");
sender.sendMessage(ChatColor.GOLD + "created, destroyed " + ChatColor.WHITE + "-- Show only created/destroyed blocks");
sender.sendMessage(ChatColor.GOLD + "chestaccess " + ChatColor.WHITE + "-- Show only chest accesses");
sender.sendMessage(ChatColor.GOLD + "entities [type1] <type2> <type3> " + ChatColor.WHITE + "-- List of entity types; can not be combined with blocks");
sender.sendMessage(ChatColor.GOLD + "area <radius> " + ChatColor.WHITE + "-- Area around you");
sender.sendMessage(ChatColor.GOLD + "selection, sel " + ChatColor.WHITE + "-- Inside current WorldEdit selection");
sender.sendMessage(ChatColor.GOLD + "world [worldname] " + ChatColor.WHITE + "-- Changes the world");
sender.sendMessage(ChatColor.GOLD + "time [number] [minutes|hours|days] " + ChatColor.WHITE + "-- Limits time");
sender.sendMessage(ChatColor.GOLD + "since <dd.MM.yyyy> <HH:mm:ss> " + ChatColor.WHITE + "-- Limits time to a fixed point");
sender.sendMessage(ChatColor.GOLD + "before <dd.MM.yyyy> <HH:mm:ss> " + ChatColor.WHITE + "-- Affects only blocks before a fixed time");
sender.sendMessage(ChatColor.GOLD + "force " + ChatColor.WHITE + "-- Forces replacing not matching blocks");
sender.sendMessage(ChatColor.GOLD + "limit <row count> " + ChatColor.WHITE + "-- Limits the result to count of rows");
sender.sendMessage(ChatColor.GOLD + "sum [none|blocks|players] " + ChatColor.WHITE + "-- Sums the result");
sender.sendMessage(ChatColor.GOLD + "asc, desc " + ChatColor.WHITE + "-- Changes the order of the displayed log");
sender.sendMessage(ChatColor.GOLD + "coords " + ChatColor.WHITE + "-- Shows coordinates for each block");
sender.sendMessage(ChatColor.GOLD + "nocache " + ChatColor.WHITE + "-- Don't set the lookup cache");
sender.sendMessage(ChatColor.GOLD + "silent " + ChatColor.WHITE + "-- Displays lesser messages");
sender.sendMessage(ChatColor.GOLD + "player [name1] <name2> <name3> -- List of players");
sender.sendMessage(ChatColor.GOLD + "block [type1] <type2> <type3> -- List of block types");
sender.sendMessage(ChatColor.GOLD + "created, destroyed -- Show only created/destroyed blocks");
sender.sendMessage(ChatColor.GOLD + "chestaccess -- Show only chest accesses");
sender.sendMessage(ChatColor.GOLD + "entities [type1] <type2> <type3> -- List of entity types; can not be combined with blocks");
sender.sendMessage(ChatColor.GOLD + "area <radius> -- Area around you");
sender.sendMessage(ChatColor.GOLD + "selection, sel -- Inside current WorldEdit selection");
sender.sendMessage(ChatColor.GOLD + "world [worldname] -- Changes the world");
sender.sendMessage(ChatColor.GOLD + "time [number] [minutes|hours|days] -- Limits time");
sender.sendMessage(ChatColor.GOLD + "since <dd.MM.yyyy> <HH:mm:ss> -- Limits time to a fixed point");
sender.sendMessage(ChatColor.GOLD + "before <dd.MM.yyyy> <HH:mm:ss> -- Affects only blocks before a fixed time");
sender.sendMessage(ChatColor.GOLD + "force -- Forces replacing not matching blocks");
sender.sendMessage(ChatColor.GOLD + "limit <row count> -- Limits the result to count of rows");
sender.sendMessage(ChatColor.GOLD + "sum [none|blocks|players] -- Sums the result");
sender.sendMessage(ChatColor.GOLD + "asc, desc -- Changes the order of the displayed log");
sender.sendMessage(ChatColor.GOLD + "coords -- Shows coordinates for each block");
sender.sendMessage(ChatColor.GOLD + "nocache -- Don't set the lookup cache");
sender.sendMessage(ChatColor.GOLD + "silent -- Displays lesser messages");
} else if (command.equals("permissions")) {
sender.sendMessage(ChatColor.DARK_AQUA + "You've got the following permissions:");
for (final String permission : new String[] { "me", "lookup", "tp", "rollback", "clearlog", "hide", "ignoreRestrictions", "spawnTools" }) {
@ -281,16 +256,13 @@ public class CommandsHandler implements CommandExecutor {
}
} else if (command.equals("page")) {
if (args.length == 2 && isInt(args[1])) {
sender.sendMessage("");
showPage(sender, Integer.valueOf(args[1]));
} else {
sender.sendMessage(ChatColor.RED + "You have to specify a page");
}
} else if (command.equals("next") || command.equals("+")) {
sender.sendMessage("");
showPage(sender, getSession(sender).page + 1);
} else if (command.equals("prev") || command.equals("-")) {
sender.sendMessage("");
showPage(sender, getSession(sender).page - 1);
} else if (args[0].equalsIgnoreCase("savequeue")) {
if (logblock.hasPermission(sender, "logblock.rollback")) {
@ -374,7 +346,7 @@ public class CommandsHandler implements CommandExecutor {
if (pos >= 0 && pos < session.lookupCache.length) {
final Location loc = session.lookupCache[pos].getLocation();
if (loc != null) {
player.teleport(new Location(loc.getWorld(), loc.getX() + 0.5, player.getGameMode() != GameMode.SPECTATOR ? safeSpawnHeight(loc) : loc.getY(), loc.getZ() + 0.5, player.getLocation().getYaw(), 90));
player.teleport(new Location(loc.getWorld(), loc.getX() + 0.5, saveSpawnHeight(loc), loc.getZ() + 0.5, player.getLocation().getYaw(), 90));
player.sendMessage(ChatColor.LIGHT_PURPLE + "Teleported to " + loc.getBlockX() + ":" + loc.getBlockY() + ":" + loc.getBlockZ());
} else {
sender.sendMessage(ChatColor.RED + "There is no location associated with that. Did you forget coords parameter?");
@ -544,7 +516,6 @@ public class CommandsHandler implements CommandExecutor {
}
state = conn.createStatement();
rs = executeQuery(state, params.getQuery());
sender.sendMessage("");
sender.sendMessage(ChatColor.DARK_AQUA + params.getTitle() + ":");
final List<LookupCacheElement> blockchanges = new ArrayList<>();
final LookupCacheElementFactory factory = new LookupCacheElementFactory(params, sender instanceof Player ? 2 / 3f : 1);
@ -700,12 +671,10 @@ public class CommandsHandler implements CommandExecutor {
logblock.getServer().getScheduler().scheduleSyncDelayedTask(logblock, new Runnable() {
@Override
public void run() {
if (player.getGameMode() != GameMode.SPECTATOR) {
final int y2 = safeSpawnHeight(loc);
loc.setY(y2);
sender.sendMessage(ChatColor.GREEN + "You were teleported " + Math.abs(y2 - y) + " blocks " + (y2 - y > 0 ? "above" : "below"));
}
final int y2 = saveSpawnHeight(loc);
loc.setY(y2);
player.teleport(loc);
sender.sendMessage(ChatColor.GREEN + "You were teleported " + Math.abs(y2 - y) + " blocks " + (y2 - y > 0 ? "above" : "below"));
}
});
} else {
@ -968,14 +937,14 @@ public class CommandsHandler implements CommandExecutor {
StringBuilder sb = new StringBuilder();
if (params.bct == BlockChangeType.CHAT) {
sb.append("INSERT INTO `lb-chat` (`id`, `date`, `playerid`, `message`) VALUES (");
sb.append(rs.getLong("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getInt("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getTimestamp("date").getTime() / 1000).append("), ");
sb.append(rs.getInt("playerid")).append(", '");
sb.append(Utils.mysqlTextEscape(rs.getString("message")));
sb.append("');\n");
} else if (params.bct == BlockChangeType.KILLS) {
sb.append("INSERT INTO `").append(tableBase).append("-kills` (`id`, `date`, `killer`, `victim`, `weapon`, `x`, `y`, `z`) VALUES (");
sb.append(rs.getLong("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getInt("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getTimestamp("date").getTime() / 1000).append("), ");
sb.append(rs.getInt("killerid")).append(", ");
sb.append(rs.getInt("victimid")).append(", ");
@ -988,7 +957,7 @@ public class CommandsHandler implements CommandExecutor {
} else {
sb.append("INSERT INTO `").append(tableBase).append("-blocks` (`id`, `date`, `playerid`, `replaced`, `replacedData`, `type`, `typeData`, `x`, `y`, `z`) VALUES (");
sb.append(rs.getLong("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getInt("id")).append(", FROM_UNIXTIME(");
sb.append(rs.getTimestamp("date").getTime() / 1000).append("), ");
sb.append(rs.getInt("playerid")).append(", ");
sb.append(rs.getInt("replaced")).append(", ");
@ -1003,7 +972,7 @@ public class CommandsHandler implements CommandExecutor {
byte[] typeState = rs.getBytes("typeState");
if (replacedState != null || typeState != null) {
sb.append("INSERT INTO `").append(tableBase).append("-state` (`id`, `replacedState`, `typeState`) VALUES (");
sb.append(rs.getLong("id")).append(", ");
sb.append(rs.getInt("id")).append(", ");
sb.append(Utils.mysqlPrepareBytesForInsertAllowNull(replacedState)).append(", ");
sb.append(Utils.mysqlPrepareBytesForInsertAllowNull(typeState));
sb.append(");\n");
@ -1011,7 +980,7 @@ public class CommandsHandler implements CommandExecutor {
byte[] item = rs.getBytes("item");
if (item != null) {
sb.append("INSERT INTO `").append(tableBase).append("-chestdata` (`id`, `item`, `itemremove`, `itemtype`) VALUES (");
sb.append(rs.getLong("id")).append(", ");
sb.append(rs.getInt("id")).append(", ");
sb.append(Utils.mysqlPrepareBytesForInsertAllowNull(item)).append(", ");
sb.append(rs.getInt("itemremove")).append(", ");
sb.append(rs.getInt("itemtype"));

2436
src/main/java/de/diddiz/LogBlock/Consumer.java
View File

File diff suppressed because it is too large Load Diff

295
src/main/java/de/diddiz/LogBlock/DumpedLogImporter.java
View File

@ -1,147 +1,148 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.Utils.newline;
import de.diddiz.LogBlock.util.Utils.ExtensionFilenameFilter;
import java.io.*;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.Comparator;
import java.util.logging.Level;
import java.util.regex.Pattern;
public class DumpedLogImporter implements Runnable {
private final LogBlock logblock;
DumpedLogImporter(LogBlock logblock) {
this.logblock = logblock;
}
@Override
public void run() {
final File[] imports = new File(logblock.getDataFolder(), "import").listFiles(new ExtensionFilenameFilter("sql"));
if (imports != null && imports.length > 0) {
logblock.getLogger().info("Found " + imports.length + " imports.");
Arrays.sort(imports, new ImportsComparator());
Connection conn = null;
try {
conn = logblock.getConnection();
if (conn == null) {
return;
}
conn.setAutoCommit(false);
final Statement st = conn.createStatement();
final BufferedWriter writer = new BufferedWriter(new FileWriter(new File(logblock.getDataFolder(), "import/failed.txt")));
int successes = 0, errors = 0;
try {
for (final File sqlFile : imports) {
String line = null;
try {
logblock.getLogger().info("Trying to import " + sqlFile.getName() + " ...");
// first try batch import the whole file
final BufferedReader reader = new BufferedReader(new FileReader(sqlFile));
int statements = 0;
while ((line = reader.readLine()) != null) {
if (line.endsWith(";")) {
line = line.substring(0, line.length() - 1);
}
if (!line.isEmpty()) {
statements++;
st.addBatch(line);
}
}
st.executeBatch();
conn.commit();
reader.close();
sqlFile.delete();
successes += statements;
logblock.getLogger().info("Successfully imported " + sqlFile.getName() + ".");
} catch (final Exception ignored) {
// if the batch import did not work, retry line by line
try {
final BufferedReader reader = new BufferedReader(new FileReader(sqlFile));
while ((line = reader.readLine()) != null) {
if (line.endsWith(";")) {
line = line.substring(0, line.length() - 1);
}
if (!line.isEmpty()) {
try {
st.execute(line);
successes++;
} catch (final SQLException ex) {
logblock.getLogger().severe("Error while importing: '" + line + "': " + ex.getMessage());
writer.write(line + newline);
errors++;
}
}
}
conn.commit();
reader.close();
sqlFile.delete();
logblock.getLogger().info("Successfully imported " + sqlFile.getName() + ".");
} catch (final Exception ex) {
logblock.getLogger().severe("Error while importing " + sqlFile.getName() + ": " + ex.getMessage());
errors++;
}
}
}
} finally {
writer.close();
}
st.close();
logblock.getLogger().info("Successfully imported stored queue. (" + successes + " rows imported, " + errors + " errors)");
} catch (final Exception ex) {
logblock.getLogger().log(Level.WARNING, "Error while importing: ", ex);
} finally {
if (conn != null) {
try {
conn.close();
} catch (final SQLException ex) {
}
}
}
}
}
private static class ImportsComparator implements Comparator<File> {
private final Pattern splitPattern = Pattern.compile("[\\-\\.]");
@Override
public int compare(File o1, File o2) {
String[] name1 = splitPattern.split(o1.getName());
String[] name2 = splitPattern.split(o2.getName());
if (name1.length > name2.length) {
return 1;
} else if (name1.length < name2.length) {
return -1;
}
for (int i = 0; i < name1.length; i++) {
String part1 = name1[i];
String part2 = name2[i];
if (part1.length() > 0 && part2.length() > 0) {
char first1 = part1.charAt(0);
char first2 = part2.charAt(0);
if (first1 >= '0' && first1 <= '9' && first2 >= '0' && first2 <= '9') {
try {
long long1 = Long.parseLong(part1);
long long2 = Long.parseLong(part2);
if (long1 == long2) {
continue;
}
return long1 > long2 ? 1 : -1;
} catch (NumberFormatException e) {
// fallthrough to string compare
}
}
}
int compareString = part1.compareTo(part2);
if (compareString != 0) {
return compareString;
}
}
return 0;
}
}
}
package de.diddiz.LogBlock;
import de.diddiz.util.Utils.ExtensionFilenameFilter;
import java.io.*;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.Comparator;
import java.util.logging.Level;
import java.util.regex.Pattern;
import static de.diddiz.util.Utils.newline;
public class DumpedLogImporter implements Runnable {
private final LogBlock logblock;
DumpedLogImporter(LogBlock logblock) {
this.logblock = logblock;
}
@Override
public void run() {
final File[] imports = new File(logblock.getDataFolder(), "import").listFiles(new ExtensionFilenameFilter("sql"));
if (imports != null && imports.length > 0) {
logblock.getLogger().info("Found " + imports.length + " imports.");
Arrays.sort(imports, new ImportsComparator());
Connection conn = null;
try {
conn = logblock.getConnection();
if (conn == null) {
return;
}
conn.setAutoCommit(false);
final Statement st = conn.createStatement();
final BufferedWriter writer = new BufferedWriter(new FileWriter(new File(logblock.getDataFolder(), "import/failed.txt")));
int successes = 0, errors = 0;
try {
for (final File sqlFile : imports) {
String line = null;
try {
logblock.getLogger().info("Trying to import " + sqlFile.getName() + " ...");
// first try batch import the whole file
final BufferedReader reader = new BufferedReader(new FileReader(sqlFile));
int statements = 0;
while ((line = reader.readLine()) != null) {
if (line.endsWith(";")) {
line = line.substring(0, line.length() - 1);
}
if (!line.isEmpty()) {
statements++;
st.addBatch(line);
}
}
st.executeBatch();
conn.commit();
reader.close();
sqlFile.delete();
successes += statements;
logblock.getLogger().info("Successfully imported " + sqlFile.getName() + ".");
} catch (final Exception ignored) {
// if the batch import did not work, retry line by line
try {
final BufferedReader reader = new BufferedReader(new FileReader(sqlFile));
while ((line = reader.readLine()) != null) {
if (line.endsWith(";")) {
line = line.substring(0, line.length() - 1);
}
if (!line.isEmpty()) {
try {
st.execute(line);
successes++;
} catch (final SQLException ex) {
logblock.getLogger().severe("Error while importing: '" + line + "': " + ex.getMessage());
writer.write(line + newline);
errors++;
}
}
}
conn.commit();
reader.close();
sqlFile.delete();
logblock.getLogger().info("Successfully imported " + sqlFile.getName() + ".");
} catch (final Exception ex) {
logblock.getLogger().severe("Error while importing " + sqlFile.getName() + ": " + ex.getMessage());
errors++;
}
}
}
} finally {
writer.close();
}
st.close();
logblock.getLogger().info("Successfully imported stored queue. (" + successes + " rows imported, " + errors + " errors)");
} catch (final Exception ex) {
logblock.getLogger().log(Level.WARNING, "Error while importing: ", ex);
} finally {
if (conn != null) {
try {
conn.close();
} catch (final SQLException ex) {
}
}
}
}
}
private static class ImportsComparator implements Comparator<File> {
private final Pattern splitPattern = Pattern.compile("[\\-\\.]");
@Override
public int compare(File o1, File o2) {
String[] name1 = splitPattern.split(o1.getName());
String[] name2 = splitPattern.split(o2.getName());
if (name1.length > name2.length) {
return 1;
} else if (name1.length < name2.length) {
return -1;
}
for (int i = 0; i < name1.length; i++) {
String part1 = name1[i];
String part2 = name2[i];
if (part1.length() > 0 && part2.length() > 0) {
char first1 = part1.charAt(0);
char first2 = part2.charAt(0);
if (first1 >= '0' && first1 <= '9' && first2 >= '0' && first2 <= '9') {
try {
long long1 = Long.parseLong(part1);
long long2 = Long.parseLong(part2);
if (long1 == long2) {
continue;
}
return long1 > long2 ? 1 : -1;
} catch (NumberFormatException e) {
// fallthrough to string compare
}
}
}
int compareString = part1.compareTo(part2);
if (compareString != 0) {
return compareString;
}
}
return 0;
}
}
}

20
src/main/java/de/diddiz/LogBlock/EntityChange.java
View File

@ -1,15 +1,15 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.ActionColor.CREATE;
import static de.diddiz.LogBlock.util.ActionColor.DESTROY;
import static de.diddiz.LogBlock.util.ActionColor.INTERACT;
import static de.diddiz.LogBlock.util.MessagingUtil.createTextComponentWithColor;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyDate;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyEntityType;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyLocation;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyMaterial;
import static de.diddiz.util.ActionColor.CREATE;
import static de.diddiz.util.ActionColor.DESTROY;
import static de.diddiz.util.ActionColor.INTERACT;
import static de.diddiz.util.MessagingUtil.createTextComponentWithColor;
import static de.diddiz.util.MessagingUtil.prettyDate;
import static de.diddiz.util.MessagingUtil.prettyEntityType;
import static de.diddiz.util.MessagingUtil.prettyLocation;
import static de.diddiz.util.MessagingUtil.prettyMaterial;
import de.diddiz.LogBlock.util.Utils;
import de.diddiz.util.Utils;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.UUID;
@ -60,7 +60,7 @@ public class EntityChange implements LookupCacheElement {
}
public EntityChange(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getLong("id") : 0;
id = p.needId ? rs.getInt("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
loc = p.needCoords ? new Location(p.world, rs.getInt("x"), rs.getInt("y"), rs.getInt("z")) : null;
actor = p.needPlayer ? new Actor(rs) : null;

15
src/main/java/de/diddiz/LogBlock/Kill.java
View File

@ -1,12 +1,11 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.ActionColor.DESTROY;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyDate;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyLocation;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyMaterial;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.MessagingUtil;
import static de.diddiz.util.ActionColor.DESTROY;
import static de.diddiz.util.MessagingUtil.prettyDate;
import static de.diddiz.util.MessagingUtil.prettyLocation;
import static de.diddiz.util.MessagingUtil.prettyMaterial;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.MessagingUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import net.md_5.bungee.api.chat.BaseComponent;
@ -30,7 +29,7 @@ public class Kill implements LookupCacheElement {
}
public Kill(ResultSet rs, QueryParams p) throws SQLException {
id = p.needId ? rs.getLong("id") : 0;
id = p.needId ? rs.getInt("id") : 0;
date = p.needDate ? rs.getTimestamp("date").getTime() : 0;
loc = p.needCoords ? new Location(p.world, rs.getInt("x"), rs.getInt("y"), rs.getInt("z")) : null;
killerName = p.needKiller ? rs.getString("killer") : null;

736
src/main/java/de/diddiz/LogBlock/LogBlock.java
View File

@ -1,386 +1,350 @@
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.addons.worldguard.WorldGuardLoggingFlagsAddon;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.listeners.*;
import de.diddiz.LogBlock.questioner.Questioner;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.MySQLConnectionPool;
import de.diddiz.LogBlock.worldedit.WorldEditHelper;
import de.diddiz.LogBlock.worldedit.WorldEditLoggingHook;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.File;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import static de.diddiz.LogBlock.config.Config.*;
import static org.bukkit.Bukkit.getPluginManager;
public class LogBlock extends JavaPlugin {
private static LogBlock logblock = null;
private MySQLConnectionPool pool;
private Consumer consumer = null;
private CommandsHandler commandsHandler;
private boolean noDb = false, connected = true;
private PlayerInfoLogging playerInfoLogging;
private ScaffoldingLogging scaffoldingLogging;
private Questioner questioner;
private WorldGuardLoggingFlagsAddon worldGuardLoggingFlagsAddon;
private boolean isConfigLoaded;
private volatile boolean isCompletelyEnabled;
public static LogBlock getInstance() {
return logblock;
}
public boolean isCompletelyEnabled() {
return isCompletelyEnabled;
}
public Consumer getConsumer() {
return consumer;
}
public CommandsHandler getCommandsHandler() {
return commandsHandler;
}
@Override
public void onLoad() {
logblock = this;
BukkitUtils.isDoublePlant(Material.AIR); // Force static code to run
try {
Config.load(this);
isConfigLoaded = true;
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Could not load LogBlock config! " + ex.getMessage(), ex);
}
if (Config.worldGuardLoggingFlags) {
if (getServer().getPluginManager().getPlugin("WorldGuard") == null) {
getLogger().log(Level.SEVERE, "Invalid config! addons.worldguardLoggingFlags is set to true, but WorldGuard is not loaded.");
} else {
worldGuardLoggingFlagsAddon = new WorldGuardLoggingFlagsAddon(this);
worldGuardLoggingFlagsAddon.onPluginLoad();
}
}
}
@Override
public void onEnable() {
final PluginManager pm = getPluginManager();
if (!isConfigLoaded) {
pm.disablePlugin(this);
return;
}
consumer = new Consumer(this);
try {
getLogger().info("Connecting to " + user + "@" + url + "...");
try {
Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException ignored) {
Class.forName("com.mysql.jdbc.Driver");
}
pool = new MySQLConnectionPool(url, user, password, mysqlUseSSL, mysqlRequireSSL);
final Connection conn = getConnection(true);
if (conn == null) {
noDb = true;
return;
}
final Statement st = conn.createStatement();
try {
final ResultSet rs = st.executeQuery("SHOW CHARACTER SET where charset='utf8mb4';");
if (rs.next()) {
Config.mb4 = true;
// Allegedly JDBC driver since 2010 hasn't needed this. I did.
try {
st.executeUpdate("SET NAMES utf8mb4;");
} catch (Exception ex) {
getLogger().severe("could not set names to utf8mb4: " + ex.getMessage());
}
}
} catch (Exception ex) {
getLogger().severe("could not verify character set: " + ex.getMessage());
}
conn.close();
Updater updater = new Updater(this);
updater.checkTables();
MaterialConverter.initializeMaterials(getConnection());
MaterialConverter.getOrAddMaterialId(Material.AIR); // AIR must be the first entry
EntityTypeConverter.initializeEntityTypes(getConnection());
if (updater.update()) {
load(this);
}
} catch (final NullPointerException ex) {
getLogger().log(Level.SEVERE, "Error while loading: ", ex);
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Error while loading: " + ex.getMessage(), ex);
pm.disablePlugin(this);
return;
}
if (WorldEditHelper.hasWorldEdit()) {
new WorldEditLoggingHook(this).hook();
}
commandsHandler = new CommandsHandler(this);
getCommand("lb").setExecutor(commandsHandler);
if (enableAutoClearLog && autoClearLogDelay > 0) {
getServer().getScheduler().runTaskTimerAsynchronously(this, new AutoClearLog(this), 6000, autoClearLogDelay * 60 * 20);
}
new DumpedLogImporter(this).run();
registerEvents();
consumer.start();
for (final Tool tool : toolsByType.values()) {
if (pm.getPermission("logblock.tools." + tool.name) == null) {
final Permission perm = new Permission("logblock.tools." + tool.name, tool.permissionDefault);
pm.addPermission(perm);
}
}
questioner = new Questioner(this);
if (worldGuardLoggingFlagsAddon != null) {
worldGuardLoggingFlagsAddon.onPluginEnable();
}
isCompletelyEnabled = true;
getServer().getScheduler().runTaskAsynchronously(this, new Updater.PlayerCountChecker(this));
}
private void registerEvents() {
final PluginManager pm = getPluginManager();
pm.registerEvents(new ToolListener(this), this);
pm.registerEvents(playerInfoLogging = new PlayerInfoLogging(this), this);
if (askRollbackAfterBan) {
pm.registerEvents(new BanListener(this), this);
}
if (isLogging(Logging.BLOCKPLACE)) {
pm.registerEvents(new BlockPlaceLogging(this), this);
}
if (isLogging(Logging.LAVAFLOW) || isLogging(Logging.WATERFLOW)) {
pm.registerEvents(new FluidFlowLogging(this), this);
}
if (isLogging(Logging.BLOCKBREAK)) {
pm.registerEvents(new BlockBreakLogging(this), this);
}
if (isLogging(Logging.SIGNTEXT)) {
pm.registerEvents(new SignChangeLogging(this), this);
}
if (isLogging(Logging.FIRE)) {
pm.registerEvents(new BlockBurnLogging(this), this);
}
if (isLogging(Logging.SNOWFORM)) {
pm.registerEvents(new SnowFormLogging(this), this);
}
if (isLogging(Logging.SNOWFADE)) {
pm.registerEvents(new SnowFadeLogging(this), this);
}
if (isLogging(Logging.SCAFFOLDING)) {
pm.registerEvents(scaffoldingLogging = new ScaffoldingLogging(this), this);
}
if (isLogging(Logging.CAULDRONINTERACT)) {
pm.registerEvents(new CauldronLogging(this), this);
}
if (isLogging(Logging.CREEPEREXPLOSION) || isLogging(Logging.TNTEXPLOSION) || isLogging(Logging.GHASTFIREBALLEXPLOSION) || isLogging(Logging.ENDERDRAGON) || isLogging(Logging.MISCEXPLOSION)) {
pm.registerEvents(new ExplosionLogging(this), this);
}
if (isLogging(Logging.LEAVESDECAY)) {
pm.registerEvents(new LeavesDecayLogging(this), this);
}
if (isLogging(Logging.CHESTACCESS)) {
pm.registerEvents(new ChestAccessLogging(this), this);
}
if (isLogging(Logging.BLOCKBREAK) || isLogging(Logging.BLOCKPLACE) || isLogging(Logging.SWITCHINTERACT) || isLogging(Logging.DOORINTERACT) || isLogging(Logging.CAKEEAT) || isLogging(Logging.DIODEINTERACT) || isLogging(Logging.COMPARATORINTERACT) || isLogging(Logging.NOTEBLOCKINTERACT)
|| isLogging(Logging.PRESUREPLATEINTERACT) || isLogging(Logging.TRIPWIREINTERACT) || isLogging(Logging.CROPTRAMPLE)) {
pm.registerEvents(new InteractLogging(this), this);
}
if (isLogging(Logging.CREATURECROPTRAMPLE)) {
pm.registerEvents(new CreatureInteractLogging(this), this);
}
if (isLogging(Logging.KILL)) {
pm.registerEvents(new KillLogging(this), this);
}
if (isLogging(Logging.CHAT) || isLogging(Logging.PLAYER_COMMANDS) || isLogging(Logging.CONSOLE_COMMANDS) || isLogging(Logging.COMMANDBLOCK_COMMANDS)) {
pm.registerEvents(new ChatLogging(this), this);
}
if (isLogging(Logging.ENDERMEN)) {
pm.registerEvents(new EndermenLogging(this), this);
}
if (isLogging(Logging.WITHER)) {
pm.registerEvents(new WitherLogging(this), this);
}
if (isLogging(Logging.NATURALSTRUCTUREGROW)) {
pm.registerEvents(new StructureGrowLogging(this), this);
}
if (isLogging(Logging.BONEMEALSTRUCTUREGROW)) {
pm.registerEvents(new BlockFertilizeLogging(this), this);
}
if (isLogging(Logging.GRASSGROWTH) || isLogging(Logging.MYCELIUMSPREAD) || isLogging(Logging.VINEGROWTH) || isLogging(Logging.MUSHROOMSPREAD) || isLogging(Logging.BAMBOOGROWTH) || isLogging(Logging.DRIPSTONEGROWTH) || isLogging(Logging.SCULKSPREAD)) {
pm.registerEvents(new BlockSpreadLogging(this), this);
}
if (isLogging(Logging.DRAGONEGGTELEPORT)) {
pm.registerEvents(new DragonEggLogging(this), this);
}
if (isLogging(Logging.LECTERNBOOKCHANGE)) {
pm.registerEvents(new LecternLogging(this), this);
}
if (isLogging(Logging.OXIDIZATION)) {
pm.registerEvents(new OxidizationLogging(this), this);
}
if (Config.isLoggingAnyEntities()) {
if (!WorldEditHelper.hasFullWorldEdit()) {
getLogger().severe("No compatible WorldEdit found, entity logging will not work!");
} else {
pm.registerEvents(new AdvancedEntityLogging(this), this);
getLogger().info("Entity logging enabled!");
}
}
}
@Override
public void onDisable() {
isCompletelyEnabled = false;
getServer().getScheduler().cancelTasks(this);
if (consumer != null) {
if (logPlayerInfo && playerInfoLogging != null) {
for (final Player player : getServer().getOnlinePlayers()) {
playerInfoLogging.onPlayerQuit(player);
}
}
getLogger().info("Waiting for consumer ...");
consumer.shutdown();
if (consumer.getQueueSize() > 0) {
getLogger().info("Remaining queue size: " + consumer.getQueueSize() + ". Trying to write to a local file.");
try {
consumer.writeToFile();
getLogger().info("Successfully dumped queue.");
} catch (final FileNotFoundException ex) {
getLogger().info("Failed to write. Given up.");
}
}
}
if (pool != null) {
pool.close();
}
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
if (noDb) {
sender.sendMessage(ChatColor.RED + "No database connected. Check your MySQL user/pw and database for typos. Start/restart your MySQL server.");
}
return true;
}
public boolean hasPermission(CommandSender sender, String permission) {
return sender.hasPermission(permission);
}
public Connection getConnection() {
return getConnection(false);
}
public Connection getConnection(boolean testConnection) {
try {
final Connection conn = pool.getConnection();
if (!connected) {
getLogger().info("MySQL connection rebuild");
connected = true;
}
return conn;
} catch (final Exception ex) {
if (testConnection) {
getLogger().log(Level.SEVERE, "Could not connect to the Database! Please check your config! " + ex.getMessage());
} else if (connected) {
getLogger().log(Level.SEVERE, "Error while fetching connection: ", ex);
connected = false;
} else {
getLogger().log(Level.SEVERE, "MySQL connection lost", ex);
}
return null;
}
}
/**
* Returns a list of block changes based on the given query parameters, the query parameters
* are essentially programmatic versions of the parameters a player would pass
* to the logblock lookup command i.e /lb lookup <i>query-parameters</i>
*
* Note: this method directly calls a SQL query and is hence a slow blocking function, avoid running
* it on the main game thread
*
* @param params QueryParams that contains the needed columns (all other will be filled with default values) and the params. World is required.
* @return Returns a list of block changes based on the given query parameters
* @throws SQLException if a sql exception occurs while looking up the block changes
*/
public List<BlockChange> getBlockChanges(QueryParams params) throws SQLException {
final Connection conn = getConnection();
Statement state = null;
if (conn == null) {
throw new SQLException("No connection");
}
try {
state = conn.createStatement();
final ResultSet rs = state.executeQuery(params.getQuery());
final List<BlockChange> blockchanges = new ArrayList<>();
while (rs.next()) {
blockchanges.add(new BlockChange(rs, params));
}
return blockchanges;
} finally {
if (state != null) {
state.close();
}
conn.close();
}
}
public int getCount(QueryParams params) throws SQLException {
if (params == null || params.world == null || !Config.isLogged(params.world)) {
throw new IllegalArgumentException("World is not logged: " + ((params == null || params.world == null) ? "null" : params.world.getName()));
}
final Connection conn = getConnection();
Statement state = null;
if (conn == null) {
throw new SQLException("No connection");
}
try {
state = conn.createStatement();
final QueryParams p = params.clone();
p.needCount = true;
final ResultSet rs = state.executeQuery(p.getQuery());
if (!rs.next()) {
return 0;
}
return rs.getInt(1);
} finally {
if (state != null) {
state.close();
}
conn.close();
}
}
@Override
public File getFile() {
return super.getFile();
}
public Questioner getQuestioner() {
return questioner;
}
public ScaffoldingLogging getScaffoldingLogging() {
return scaffoldingLogging;
}
}
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.listeners.*;
import de.diddiz.LogBlock.questioner.Questioner;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.MySQLConnectionPool;
import de.diddiz.worldedit.WorldEditHelper;
import de.diddiz.worldedit.WorldEditLoggingHook;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.File;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import static de.diddiz.LogBlock.config.Config.*;
import static org.bukkit.Bukkit.getPluginManager;
public class LogBlock extends JavaPlugin {
private static LogBlock logblock = null;
private MySQLConnectionPool pool;
private Consumer consumer = null;
private CommandsHandler commandsHandler;
private boolean noDb = false, connected = true;
private PlayerInfoLogging playerInfoLogging;
private ScaffoldingLogging scaffoldingLogging;
private Questioner questioner;
private volatile boolean isCompletelyEnabled;
public static LogBlock getInstance() {
return logblock;
}
public boolean isCompletelyEnabled() {
return isCompletelyEnabled;
}
public Consumer getConsumer() {
return consumer;
}
public CommandsHandler getCommandsHandler() {
return commandsHandler;
}
@Override
public void onEnable() {
logblock = this;
BukkitUtils.isDoublePlant(Material.AIR); // Force static code to run
final PluginManager pm = getPluginManager();
consumer = new Consumer(this);
try {
Config.load(this);
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Could not load LogBlock config! " + ex.getMessage());
pm.disablePlugin(this);
return;
}
try {
getLogger().info("Connecting to " + user + "@" + url + "...");
try {
Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException ignored) {
Class.forName("com.mysql.jdbc.Driver");
}
pool = new MySQLConnectionPool(url, user, password, mysqlUseSSL, mysqlRequireSSL);
final Connection conn = getConnection(true);
if (conn == null) {
noDb = true;
return;
}
final Statement st = conn.createStatement();
final ResultSet rs = st.executeQuery("SHOW CHARACTER SET where charset='utf8mb4';");
if (rs.next()) {
Config.mb4 = true;
// Allegedly JDBC driver since 2010 hasn't needed this. I did.
st.executeQuery("SET NAMES utf8mb4;");
}
conn.close();
Updater updater = new Updater(this);
updater.checkTables();
MaterialConverter.initializeMaterials(getConnection());
MaterialConverter.getOrAddMaterialId(Material.AIR); // AIR must be the first entry
EntityTypeConverter.initializeEntityTypes(getConnection());
if (updater.update()) {
load(this);
}
} catch (final NullPointerException ex) {
getLogger().log(Level.SEVERE, "Error while loading: ", ex);
} catch (final Exception ex) {
getLogger().log(Level.SEVERE, "Error while loading: " + ex.getMessage(), ex);
pm.disablePlugin(this);
return;
}
if (WorldEditHelper.hasWorldEdit()) {
new WorldEditLoggingHook(this).hook();
}
commandsHandler = new CommandsHandler(this);
getCommand("lb").setExecutor(commandsHandler);
if (enableAutoClearLog && autoClearLogDelay > 0) {
getServer().getScheduler().runTaskTimerAsynchronously(this, new AutoClearLog(this), 6000, autoClearLogDelay * 60 * 20);
}
new DumpedLogImporter(this).run();
registerEvents();
consumer.start();
for (final Tool tool : toolsByType.values()) {
if (pm.getPermission("logblock.tools." + tool.name) == null) {
final Permission perm = new Permission("logblock.tools." + tool.name, tool.permissionDefault);
pm.addPermission(perm);
}
}
questioner = new Questioner(this);
isCompletelyEnabled = true;
getServer().getScheduler().runTaskAsynchronously(this, new Updater.PlayerCountChecker(this));
}
private void registerEvents() {
final PluginManager pm = getPluginManager();
pm.registerEvents(new ToolListener(this), this);
pm.registerEvents(playerInfoLogging = new PlayerInfoLogging(this), this);
if (askRollbackAfterBan) {
pm.registerEvents(new BanListener(this), this);
}
if (isLogging(Logging.BLOCKPLACE)) {
pm.registerEvents(new BlockPlaceLogging(this), this);
}
if (isLogging(Logging.LAVAFLOW) || isLogging(Logging.WATERFLOW)) {
pm.registerEvents(new FluidFlowLogging(this), this);
}
if (isLogging(Logging.BLOCKBREAK)) {
pm.registerEvents(new BlockBreakLogging(this), this);
}
if (isLogging(Logging.SIGNTEXT)) {
pm.registerEvents(new SignChangeLogging(this), this);
}
if (isLogging(Logging.FIRE)) {
pm.registerEvents(new BlockBurnLogging(this), this);
}
if (isLogging(Logging.SNOWFORM)) {
pm.registerEvents(new SnowFormLogging(this), this);
}
if (isLogging(Logging.SNOWFADE)) {
pm.registerEvents(new SnowFadeLogging(this), this);
}
if (isLogging(Logging.SCAFFOLDING)) {
pm.registerEvents(scaffoldingLogging = new ScaffoldingLogging(this), this);
}
if (isLogging(Logging.CREEPEREXPLOSION) || isLogging(Logging.TNTEXPLOSION) || isLogging(Logging.GHASTFIREBALLEXPLOSION) || isLogging(Logging.ENDERDRAGON) || isLogging(Logging.MISCEXPLOSION)) {
pm.registerEvents(new ExplosionLogging(this), this);
}
if (isLogging(Logging.LEAVESDECAY)) {
pm.registerEvents(new LeavesDecayLogging(this), this);
}
if (isLogging(Logging.CHESTACCESS)) {
pm.registerEvents(new ChestAccessLogging(this), this);
}
if (isLogging(Logging.BLOCKBREAK) || isLogging(Logging.BLOCKPLACE) || isLogging(Logging.SWITCHINTERACT) || isLogging(Logging.DOORINTERACT) || isLogging(Logging.CAKEEAT) || isLogging(Logging.DIODEINTERACT) || isLogging(Logging.COMPARATORINTERACT) || isLogging(Logging.NOTEBLOCKINTERACT)
|| isLogging(Logging.PRESUREPLATEINTERACT) || isLogging(Logging.TRIPWIREINTERACT) || isLogging(Logging.CROPTRAMPLE)) {
pm.registerEvents(new InteractLogging(this), this);
}
if (isLogging(Logging.CREATURECROPTRAMPLE)) {
pm.registerEvents(new CreatureInteractLogging(this), this);
}
if (isLogging(Logging.KILL)) {
pm.registerEvents(new KillLogging(this), this);
}
if (isLogging(Logging.CHAT) || isLogging(Logging.PLAYER_COMMANDS) || isLogging(Logging.CONSOLE_COMMANDS) || isLogging(Logging.COMMANDBLOCK_COMMANDS)) {
pm.registerEvents(new ChatLogging(this), this);
}
if (isLogging(Logging.ENDERMEN)) {
pm.registerEvents(new EndermenLogging(this), this);
}
if (isLogging(Logging.WITHER)) {
pm.registerEvents(new WitherLogging(this), this);
}
if (isLogging(Logging.NATURALSTRUCTUREGROW) || isLogging(Logging.BONEMEALSTRUCTUREGROW)) {
pm.registerEvents(new StructureGrowLogging(this), this);
}
if (isLogging(Logging.GRASSGROWTH) || isLogging(Logging.MYCELIUMSPREAD) || isLogging(Logging.VINEGROWTH) || isLogging(Logging.MUSHROOMSPREAD)) {
pm.registerEvents(new BlockSpreadLogging(this), this);
}
if (isLogging(Logging.DRAGONEGGTELEPORT)) {
pm.registerEvents(new DragonEggLogging(this), this);
}
if (isLogging(Logging.LECTERNBOOKCHANGE)) {
pm.registerEvents(new LecternLogging(this), this);
}
if (Config.isLoggingAnyEntities()) {
if (!WorldEditHelper.hasFullWorldEdit()) {
getLogger().severe("No compatible WorldEdit found, entity logging will not work!");
} else {
pm.registerEvents(new AdvancedEntityLogging(this), this);
getLogger().info("Entity logging enabled!");
}
}
}
@Override
public void onDisable() {
isCompletelyEnabled = false;
getServer().getScheduler().cancelTasks(this);
if (consumer != null) {
if (logPlayerInfo && playerInfoLogging != null) {
for (final Player player : getServer().getOnlinePlayers()) {
playerInfoLogging.onPlayerQuit(player);
}
}
getLogger().info("Waiting for consumer ...");
consumer.shutdown();
if (consumer.getQueueSize() > 0) {
getLogger().info("Remaining queue size: " + consumer.getQueueSize() + ". Trying to write to a local file.");
try {
consumer.writeToFile();
getLogger().info("Successfully dumped queue.");
} catch (final FileNotFoundException ex) {
getLogger().info("Failed to write. Given up.");
}
}
}
if (pool != null) {
pool.close();
}
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
if (noDb) {
sender.sendMessage(ChatColor.RED + "No database connected. Check your MySQL user/pw and database for typos. Start/restart your MySQL server.");
}
return true;
}
public boolean hasPermission(CommandSender sender, String permission) {
return sender.hasPermission(permission);
}
public Connection getConnection() {
return getConnection(false);
}
public Connection getConnection(boolean testConnection) {
try {
final Connection conn = pool.getConnection();
if (!connected) {
getLogger().info("MySQL connection rebuild");
connected = true;
}
return conn;
} catch (final Exception ex) {
if (testConnection) {
getLogger().log(Level.SEVERE, "Could not connect to the Database! Please check your config! " + ex.getMessage());
} else if (connected) {
getLogger().log(Level.SEVERE, "Error while fetching connection: ", ex);
connected = false;
} else {
getLogger().log(Level.SEVERE, "MySQL connection lost", ex);
}
return null;
}
}
/**
* Returns a list of block changes based on the given query parameters, the query parameters
* are essentially programmatic versions of the parameters a player would pass
* to the logblock lookup command i.e /lb lookup <i>query-parameters</i>
*
* Note: this method directly calls a SQL query and is hence a slow blocking function, avoid running
* it on the main game thread
*
* @param params QueryParams that contains the needed columns (all other will be filled with default values) and the params. World is required.
* @return Returns a list of block changes based on the given query parameters
* @throws SQLException if a sql exception occurs while looking up the block changes
*/
public List<BlockChange> getBlockChanges(QueryParams params) throws SQLException {
final Connection conn = getConnection();
Statement state = null;
if (conn == null) {
throw new SQLException("No connection");
}
try {
state = conn.createStatement();
final ResultSet rs = state.executeQuery(params.getQuery());
final List<BlockChange> blockchanges = new ArrayList<>();
while (rs.next()) {
blockchanges.add(new BlockChange(rs, params));
}
return blockchanges;
} finally {
if (state != null) {
state.close();
}
conn.close();
}
}
public int getCount(QueryParams params) throws SQLException {
if (params == null || params.world == null || !Config.isLogged(params.world)) {
throw new IllegalArgumentException("World is not logged: " + ((params == null || params.world == null) ? "null" : params.world.getName()));
}
final Connection conn = getConnection();
Statement state = null;
if (conn == null) {
throw new SQLException("No connection");
}
try {
state = conn.createStatement();
final QueryParams p = params.clone();
p.needCount = true;
final ResultSet rs = state.executeQuery(p.getQuery());
if (!rs.next()) {
return 0;
}
return rs.getInt(1);
} finally {
if (state != null) {
state.close();
}
conn.close();
}
}
@Override
public File getFile() {
return super.getFile();
}
public Questioner getQuestioner() {
return questioner;
}
public ScaffoldingLogging getScaffoldingLogging() {
return scaffoldingLogging;
}
}

5
src/main/java/de/diddiz/LogBlock/Logging.java
View File

@ -27,14 +27,12 @@ public enum Logging {
COMPARATORINTERACT,
PRESUREPLATEINTERACT,
TRIPWIREINTERACT,
CAULDRONINTERACT(true),
CREATURECROPTRAMPLE,
CROPTRAMPLE,
NATURALSTRUCTUREGROW,
GRASSGROWTH,
MYCELIUMSPREAD,
VINEGROWTH,
DRIPSTONEGROWTH,
MUSHROOMSPREAD,
BAMBOOGROWTH,
WITHER(true),
@ -48,10 +46,7 @@ public enum Logging {
DAYLIGHTDETECTORINTERACT,
LECTERNBOOKCHANGE(true),
SCAFFOLDING(true),
OXIDIZATION,
SCULKSPREAD(true),
SHULKER_BOX_CONTENT,
RESPAWNANCHOREXPLOSION(true),
PLAYER_COMMANDS,
COMMANDBLOCK_COMMANDS,
CONSOLE_COMMANDS;

36
src/main/java/de/diddiz/LogBlock/LookupCacheElement.java
View File

@ -1,18 +1,18 @@
package de.diddiz.LogBlock;
import net.md_5.bungee.api.chat.BaseComponent;
import org.bukkit.Location;
public interface LookupCacheElement {
public Location getLocation();
public default BaseComponent[] getLogMessage() {
return getLogMessage(-1);
}
public BaseComponent[] getLogMessage(int entry);
public default int getNumChanges() {
return 1;
}
}
package de.diddiz.LogBlock;
import net.md_5.bungee.api.chat.BaseComponent;
import org.bukkit.Location;
public interface LookupCacheElement {
public Location getLocation();
public default BaseComponent[] getLogMessage() {
return getLogMessage(-1);
}
public BaseComponent[] getLogMessage(int entry);
public default int getNumChanges() {
return 1;
}
}

80
src/main/java/de/diddiz/LogBlock/LookupCacheElementFactory.java
View File

@ -1,40 +1,40 @@
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.QueryParams.BlockChangeType;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import java.sql.ResultSet;
import java.sql.SQLException;
public class LookupCacheElementFactory {
private final QueryParams params;
private final float spaceFactor;
public LookupCacheElementFactory(QueryParams params, float spaceFactor) {
this.params = params;
this.spaceFactor = spaceFactor;
}
public LookupCacheElement getLookupCacheElement(ResultSet rs) throws SQLException {
if (params.bct == BlockChangeType.CHAT) {
return new ChatMessage(rs, params);
}
if (params.bct == BlockChangeType.KILLS) {
if (params.sum == SummarizationMode.NONE) {
return new Kill(rs, params);
} else if (params.sum == SummarizationMode.PLAYERS) {
return new SummedKills(rs, params, spaceFactor);
}
}
if (params.bct == BlockChangeType.ENTITIES || params.bct == BlockChangeType.ENTITIES_CREATED || params.bct == BlockChangeType.ENTITIES_KILLED) {
if (params.sum == SummarizationMode.NONE) {
return new EntityChange(rs, params);
}
return new SummedEntityChanges(rs, params, spaceFactor);
}
if (params.sum == SummarizationMode.NONE) {
return new BlockChange(rs, params);
}
return new SummedBlockChanges(rs, params, spaceFactor);
}
}
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.QueryParams.BlockChangeType;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import java.sql.ResultSet;
import java.sql.SQLException;
public class LookupCacheElementFactory {
private final QueryParams params;
private final float spaceFactor;
public LookupCacheElementFactory(QueryParams params, float spaceFactor) {
this.params = params;
this.spaceFactor = spaceFactor;
}
public LookupCacheElement getLookupCacheElement(ResultSet rs) throws SQLException {
if (params.bct == BlockChangeType.CHAT) {
return new ChatMessage(rs, params);
}
if (params.bct == BlockChangeType.KILLS) {
if (params.sum == SummarizationMode.NONE) {
return new Kill(rs, params);
} else if (params.sum == SummarizationMode.PLAYERS) {
return new SummedKills(rs, params, spaceFactor);
}
}
if (params.bct == BlockChangeType.ENTITIES || params.bct == BlockChangeType.ENTITIES_CREATED || params.bct == BlockChangeType.ENTITIES_KILLED) {
if (params.sum == SummarizationMode.NONE) {
return new EntityChange(rs, params);
}
return new SummedEntityChanges(rs, params, spaceFactor);
}
if (params.sum == SummarizationMode.NONE) {
return new BlockChange(rs, params);
}
return new SummedBlockChanges(rs, params, spaceFactor);
}
}

29
src/main/java/de/diddiz/LogBlock/QueryParams.java
View File

@ -1,11 +1,11 @@
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.CuboidRegion;
import de.diddiz.LogBlock.util.SqlUtil;
import de.diddiz.LogBlock.util.Utils;
import de.diddiz.LogBlock.worldedit.WorldEditHelper;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.CuboidRegion;
import de.diddiz.util.SqlUtil;
import de.diddiz.util.Utils;
import de.diddiz.worldedit.WorldEditHelper;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
@ -20,8 +20,8 @@ import java.util.regex.Pattern;
import static de.diddiz.LogBlock.Session.getSession;
import static de.diddiz.LogBlock.config.Config.*;
import static de.diddiz.LogBlock.util.BukkitUtils.friendlyWorldname;
import static de.diddiz.LogBlock.util.Utils.*;
import static de.diddiz.util.BukkitUtils.friendlyWorldname;
import static de.diddiz.util.Utils.*;
public final class QueryParams implements Cloneable {
private static final HashMap<String, Integer> keywords = new HashMap<>();
@ -691,20 +691,16 @@ public final class QueryParams implements Cloneable {
if (values.length < 1) {
throw new IllegalArgumentException("No or wrong count of arguments for '" + param + "'");
}
for (String playerName : values) {
for (final String playerName : values) {
if (playerName.length() > 0) {
if (playerName.startsWith("!")) {
playerName = playerName.substring(1);
if (playerName.contains("!")) {
excludePlayersMode = true;
if (playerName.isEmpty()) {
continue;
}
}
if (playerName.contains("\"")) {
players.add(playerName.replace("\"", ""));
players.add(playerName.replaceAll("[^a-zA-Z0-9_]", ""));
} else {
final Player matches = logblock.getServer().getPlayerExact(playerName);
players.add(matches != null ? matches.getName() : playerName.replace("\\\"", ""));
players.add(matches != null ? matches.getName() : playerName.replaceAll("[^a-zA-Z0-9_]", ""));
}
}
}
@ -857,9 +853,6 @@ public final class QueryParams implements Cloneable {
if (values[0].startsWith("p")) {
sum = SummarizationMode.PLAYERS;
} else if (values[0].startsWith("b") || values[0].startsWith("e")) {
if (values[0].startsWith("e")) {
bct = BlockChangeType.ENTITIES;
}
sum = SummarizationMode.TYPES;
} else if (values[0].startsWith("n")) {
sum = SummarizationMode.NONE;

98
src/main/java/de/diddiz/LogBlock/Session.java
View File

@ -1,49 +1,49 @@
package de.diddiz.LogBlock;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
import static de.diddiz.LogBlock.config.Config.toolsByType;
import static org.bukkit.Bukkit.getServer;
public class Session {
private static final Map<String, Session> sessions = new HashMap<>();
public QueryParams lastQuery = null;
public LookupCacheElement[] lookupCache = null;
public int page = 1;
public Map<Tool, ToolData> toolData;
private Session(Player player) {
toolData = new HashMap<>();
final LogBlock logblock = LogBlock.getInstance();
if (player != null) {
for (final Tool tool : toolsByType.values()) {
toolData.put(tool, new ToolData(tool, logblock, player));
}
}
}
public static boolean hasSession(CommandSender sender) {
return sessions.containsKey(sender.getName().toLowerCase());
}
public static boolean hasSession(String playerName) {
return sessions.containsKey(playerName.toLowerCase());
}
public static Session getSession(CommandSender sender) {
return getSession(sender.getName());
}
public static Session getSession(String playerName) {
Session session = sessions.get(playerName.toLowerCase());
if (session == null) {
session = new Session(getServer().getPlayer(playerName));
sessions.put(playerName.toLowerCase(), session);
}
return session;
}
}
package de.diddiz.LogBlock;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
import static de.diddiz.LogBlock.config.Config.toolsByType;
import static org.bukkit.Bukkit.getServer;
public class Session {
private static final Map<String, Session> sessions = new HashMap<>();
public QueryParams lastQuery = null;
public LookupCacheElement[] lookupCache = null;
public int page = 1;
public Map<Tool, ToolData> toolData;
private Session(Player player) {
toolData = new HashMap<>();
final LogBlock logblock = LogBlock.getInstance();
if (player != null) {
for (final Tool tool : toolsByType.values()) {
toolData.put(tool, new ToolData(tool, logblock, player));
}
}
}
public static boolean hasSession(CommandSender sender) {
return sessions.containsKey(sender.getName().toLowerCase());
}
public static boolean hasSession(String playerName) {
return sessions.containsKey(playerName.toLowerCase());
}
public static Session getSession(CommandSender sender) {
return getSession(sender.getName());
}
public static Session getSession(String playerName) {
Session session = sessions.get(playerName.toLowerCase());
if (session == null) {
session = new Session(getServer().getPlayer(playerName));
sessions.put(playerName.toLowerCase(), session);
}
return session;
}
}

85
src/main/java/de/diddiz/LogBlock/SummedBlockChanges.java
View File

@ -1,43 +1,42 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyMaterial;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import de.diddiz.LogBlock.util.MessagingUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Objects;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
public class SummedBlockChanges implements LookupCacheElement {
private final int type;
private final int created, destroyed;
private final float spaceFactor;
private final Actor actor;
public SummedBlockChanges(ResultSet rs, QueryParams p, float spaceFactor) throws SQLException {
// Actor currently useless here as we don't yet output UUID in results anywhere
actor = p.sum == SummarizationMode.PLAYERS ? new Actor(rs) : null;
type = p.sum == SummarizationMode.TYPES ? rs.getInt("type") : 0;
created = rs.getInt("created");
destroyed = rs.getInt("destroyed");
this.spaceFactor = spaceFactor;
}
@Override
public Location getLocation() {
return null;
}
@Override
public BaseComponent[] getLogMessage(int entry) {
return MessagingUtil.formatSummarizedChanges(created, destroyed, actor != null ? new TextComponent(actor.getName()) : prettyMaterial(Objects.toString(MaterialConverter.getMaterial(type))), 10, 10, spaceFactor);
}
@Override
public int getNumChanges() {
return created + destroyed;
}
}
package de.diddiz.LogBlock;
import static de.diddiz.util.MessagingUtil.prettyMaterial;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import de.diddiz.util.MessagingUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Objects;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Location;
public class SummedBlockChanges implements LookupCacheElement {
private final int type;
private final int created, destroyed;
private final float spaceFactor;
private final Actor actor;
public SummedBlockChanges(ResultSet rs, QueryParams p, float spaceFactor) throws SQLException {
// Actor currently useless here as we don't yet output UUID in results anywhere
actor = p.sum == SummarizationMode.PLAYERS ? new Actor(rs) : null;
type = p.sum == SummarizationMode.TYPES ? rs.getInt("type") : 0;
created = rs.getInt("created");
destroyed = rs.getInt("destroyed");
this.spaceFactor = spaceFactor;
}
@Override
public Location getLocation() {
return null;
}
@Override
public BaseComponent[] getLogMessage(int entry) {
return MessagingUtil.formatSummarizedChanges(created, destroyed, actor != null ? new TextComponent(actor.getName()) : prettyMaterial(Objects.toString(MaterialConverter.getMaterial(type))), 10, 10, spaceFactor);
}
@Override
public int getNumChanges() {
return created + destroyed;
}
}

6
src/main/java/de/diddiz/LogBlock/SummedEntityChanges.java
View File

@ -1,9 +1,7 @@
package de.diddiz.LogBlock;
import static de.diddiz.LogBlock.util.MessagingUtil.prettyMaterial;
import de.diddiz.LogBlock.QueryParams.SummarizationMode;
import de.diddiz.LogBlock.util.MessagingUtil;
import de.diddiz.util.MessagingUtil;
import org.bukkit.Location;
import java.sql.ResultSet;
@ -12,6 +10,8 @@ import java.util.Objects;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import static de.diddiz.util.MessagingUtil.prettyMaterial;
public class SummedEntityChanges implements LookupCacheElement {
private final int type;
private final int created, destroyed;

2
src/main/java/de/diddiz/LogBlock/SummedKills.java
View File

@ -1,6 +1,6 @@
package de.diddiz.LogBlock;
import de.diddiz.LogBlock.util.MessagingUtil;
import de.diddiz.util.MessagingUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import net.md_5.bungee.api.chat.BaseComponent;

70
src/main/java/de/diddiz/LogBlock/Tool.java
View File

@ -1,35 +1,35 @@
package de.diddiz.LogBlock;
import org.bukkit.Material;
import org.bukkit.permissions.PermissionDefault;
import java.util.List;
public class Tool {
public final String name;
public final List<String> aliases;
public final ToolBehavior leftClickBehavior, rightClickBehavior;
public final boolean defaultEnabled;
public final Material item;
public final boolean canDrop;
public final QueryParams params;
public final ToolMode mode;
public final PermissionDefault permissionDefault;
public final boolean removeOnDisable;
public final boolean dropToDisable;
public Tool(String name, List<String> aliases, ToolBehavior leftClickBehavior, ToolBehavior rightClickBehavior, boolean defaultEnabled, Material item, boolean canDrop, QueryParams params, ToolMode mode, PermissionDefault permissionDefault, boolean removeOnDisable, boolean dropToDisable) {
this.name = name;
this.aliases = aliases;
this.leftClickBehavior = leftClickBehavior;
this.rightClickBehavior = rightClickBehavior;
this.defaultEnabled = defaultEnabled;
this.item = item;
this.canDrop = canDrop;
this.params = params;
this.mode = mode;
this.permissionDefault = permissionDefault;
this.removeOnDisable = removeOnDisable;
this.dropToDisable = dropToDisable;
}
}
package de.diddiz.LogBlock;
import org.bukkit.Material;
import org.bukkit.permissions.PermissionDefault;
import java.util.List;
public class Tool {
public final String name;
public final List<String> aliases;
public final ToolBehavior leftClickBehavior, rightClickBehavior;
public final boolean defaultEnabled;
public final Material item;
public final boolean canDrop;
public final QueryParams params;
public final ToolMode mode;
public final PermissionDefault permissionDefault;
public final boolean removeOnDisable;
public final boolean dropToDisable;
public Tool(String name, List<String> aliases, ToolBehavior leftClickBehavior, ToolBehavior rightClickBehavior, boolean defaultEnabled, Material item, boolean canDrop, QueryParams params, ToolMode mode, PermissionDefault permissionDefault, boolean removeOnDisable, boolean dropToDisable) {
this.name = name;
this.aliases = aliases;
this.leftClickBehavior = leftClickBehavior;
this.rightClickBehavior = rightClickBehavior;
this.defaultEnabled = defaultEnabled;
this.item = item;
this.canDrop = canDrop;
this.params = params;
this.mode = mode;
this.permissionDefault = permissionDefault;
this.removeOnDisable = removeOnDisable;
this.dropToDisable = dropToDisable;
}
}

14
src/main/java/de/diddiz/LogBlock/ToolBehavior.java
View File

@ -1,7 +1,7 @@
package de.diddiz.LogBlock;
public enum ToolBehavior {
TOOL,
BLOCK,
NONE
}
package de.diddiz.LogBlock;
public enum ToolBehavior {
TOOL,
BLOCK,
NONE
}

30
src/main/java/de/diddiz/LogBlock/ToolData.java
View File

@ -1,15 +1,15 @@
package de.diddiz.LogBlock;
import org.bukkit.entity.Player;
public class ToolData {
public boolean enabled;
public QueryParams params;
public ToolMode mode;
public ToolData(Tool tool, LogBlock logblock, Player player) {
enabled = tool.defaultEnabled && logblock.hasPermission(player, "logblock.tools." + tool.name);
params = tool.params.clone();
mode = tool.mode;
}
}
package de.diddiz.LogBlock;
import org.bukkit.entity.Player;
public class ToolData {
public boolean enabled;
public QueryParams params;
public ToolMode mode;
public ToolData(Tool tool, LogBlock logblock, Player player) {
enabled = tool.defaultEnabled && logblock.hasPermission(player, "logblock.tools." + tool.name);
params = tool.params.clone();
mode = tool.mode;
}
}

36
src/main/java/de/diddiz/LogBlock/ToolMode.java
View File

@ -1,18 +1,18 @@
package de.diddiz.LogBlock;
public enum ToolMode {
CLEARLOG("logblock.clearlog"),
LOOKUP("logblock.lookup"),
REDO("logblock.rollback"),
ROLLBACK("logblock.rollback"),
WRITELOGFILE("logblock.rollback");
private final String permission;
private ToolMode(String permission) {
this.permission = permission;
}
public String getPermission() {
return permission;
}
}
package de.diddiz.LogBlock;
public enum ToolMode {
CLEARLOG("logblock.clearlog"),
LOOKUP("logblock.lookup"),
REDO("logblock.rollback"),
ROLLBACK("logblock.rollback"),
WRITELOGFILE("logblock.rollback");
private final String permission;
private ToolMode(String permission) {
this.permission = permission;
}
public String getPermission() {
return permission;
}
}

2361
src/main/java/de/diddiz/LogBlock/Updater.java
View File

File diff suppressed because it is too large Load Diff

19
src/main/java/de/diddiz/LogBlock/WorldEditor.java
View File

@ -28,9 +28,10 @@ import org.bukkit.inventory.ItemStack;
import de.diddiz.LogBlock.QueryParams.Order;
import de.diddiz.LogBlock.blockstate.BlockStateCodecs;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.Utils;
import de.diddiz.LogBlock.worldedit.WorldEditHelper;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.Utils;
import de.diddiz.worldedit.WorldEditHelper;
import java.io.File;
import java.io.PrintWriter;
import java.sql.ResultSet;
@ -48,7 +49,7 @@ import net.md_5.bungee.api.chat.TextComponent;
import static de.diddiz.LogBlock.config.Config.dontRollback;
import static de.diddiz.LogBlock.config.Config.replaceAnyway;
import static de.diddiz.LogBlock.util.BukkitUtils.*;
import static de.diddiz.util.BukkitUtils.*;
public class WorldEditor implements Runnable {
private final LogBlock logblock;
@ -182,15 +183,11 @@ public class WorldEditor implements Runnable {
logblock.getServer().getScheduler().cancelTask(taskID);
if (errorList.size() > 0) {
try {
final File errorDir = new File(logblock.getDataFolder(), "error");
errorDir.mkdirs();
final File file = new File(errorDir, "WorldEditor-" + new SimpleDateFormat("yy-MM-dd-HH-mm-ss").format(System.currentTimeMillis()) + ".log");
final File file = new File("plugins/LogBlock/error/WorldEditor-" + new SimpleDateFormat("yy-MM-dd-HH-mm-ss").format(System.currentTimeMillis()) + ".log");
file.getParentFile().mkdirs();
final PrintWriter writer = new PrintWriter(file);
for (final WorldEditorException err : errorList) {
for (final LookupCacheElement err : errorList) {
writer.println(BaseComponent.toPlainText(err.getLogMessage()));
err.printStackTrace(writer);
writer.println();
writer.println();
}
writer.close();
} catch (final Exception ex) {

2
src/main/java/de/diddiz/LogBlock/WorldEditorEditFactory.java
View File

@ -6,7 +6,7 @@ import java.sql.SQLException;
import org.bukkit.inventory.ItemStack;
import de.diddiz.LogBlock.QueryParams.BlockChangeType;
import de.diddiz.LogBlock.util.Utils;
import de.diddiz.util.Utils;
public class WorldEditorEditFactory {
private final WorldEditor editor;

80
src/main/java/de/diddiz/LogBlock/addons/worldguard/WorldGuardLoggingFlagsAddon.java
View File

@ -1,80 +0,0 @@
package de.diddiz.LogBlock.addons.worldguard;
import com.sk89q.worldedit.bukkit.BukkitAdapter;
import com.sk89q.worldguard.WorldGuard;
import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
import com.sk89q.worldguard.protection.ApplicableRegionSet;
import com.sk89q.worldguard.protection.association.RegionAssociable;
import com.sk89q.worldguard.protection.flags.StateFlag;
import com.sk89q.worldguard.protection.flags.registry.FlagConflictException;
import com.sk89q.worldguard.protection.flags.registry.FlagRegistry;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.events.BlockChangePreLogEvent;
import de.diddiz.LogBlock.events.EntityChangePreLogEvent;
import java.util.logging.Level;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
public class WorldGuardLoggingFlagsAddon {
private final StateFlag LOGBLOCK_LOG_BLOCKS = new StateFlag("logblock-log-blocks", true);
private final StateFlag LOGBLOCK_LOG_ENTITIES = new StateFlag("logblock-log-entities", true);
private LogBlock plugin;
private WorldGuardPlugin worldGuard;
public WorldGuardLoggingFlagsAddon(LogBlock plugin) {
this.plugin = plugin;
}
public void onPluginLoad() {
registerFlags();
}
public void onPluginEnable() {
worldGuard = (WorldGuardPlugin) plugin.getServer().getPluginManager().getPlugin("WorldGuard");
plugin.getServer().getPluginManager().registerEvents(new LoggingListener(), plugin);
}
private void registerFlags() {
try {
FlagRegistry registry = WorldGuard.getInstance().getFlagRegistry();
registry.register(LOGBLOCK_LOG_BLOCKS);
registry.register(LOGBLOCK_LOG_ENTITIES);
} catch (FlagConflictException e) {
plugin.getLogger().log(Level.SEVERE, "Could not initialize Flags", e);
}
}
private class LoggingListener implements Listener {
@EventHandler(ignoreCancelled = true)
public void onBlockChangePreLog(BlockChangePreLogEvent event) {
RegionAssociable regionAssociable = null;
Location location = event.getLocation();
Entity actorEntity = event.getOwnerActor().getEntity();
if (actorEntity instanceof Player) {
regionAssociable = worldGuard.wrapPlayer((Player) actorEntity);
}
ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(location));
if (!set.testState(regionAssociable, LOGBLOCK_LOG_BLOCKS)) {
event.setCancelled(true);
}
}
@EventHandler(ignoreCancelled = true)
public void onEntityChangePreLog(EntityChangePreLogEvent event) {
RegionAssociable regionAssociable = null;
Location location = event.getLocation();
Entity actorEntity = event.getOwnerActor().getEntity();
if (actorEntity instanceof Player) {
regionAssociable = worldGuard.wrapPlayer((Player) actorEntity);
}
ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(location));
if (!set.testState(regionAssociable, LOGBLOCK_LOG_ENTITIES)) {
event.setCancelled(true);
}
}
}
}

3
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodec.java
View File

@ -1,6 +1,5 @@
package de.diddiz.LogBlock.blockstate;
import net.md_5.bungee.api.chat.BaseComponent;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.configuration.file.YamlConfiguration;
@ -12,5 +11,5 @@ public interface BlockStateCodec {
void deserialize(BlockState state, YamlConfiguration conf);
BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState);
String toString(YamlConfiguration conf);
}

4
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecBanner.java
View File

@ -1,7 +1,7 @@
package de.diddiz.LogBlock.blockstate;
import java.util.List;
import net.md_5.bungee.api.chat.BaseComponent;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.block.Banner;
@ -64,7 +64,7 @@ public class BlockStateCodecBanner implements BlockStateCodec {
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState) {
public String toString(YamlConfiguration conf) {
return null;
}
}

10
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecLectern.java
View File

@ -1,7 +1,5 @@
package de.diddiz.LogBlock.blockstate;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.Lectern;
@ -45,10 +43,12 @@ public class BlockStateCodecLectern implements BlockStateCodec {
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState) {
public String toString(YamlConfiguration conf) {
if (conf != null) {
return new TextComponent("[book]");
StringBuilder sb = new StringBuilder();
sb.append("[").append("book").append("]");
return sb.toString();
}
return new TextComponent("empty");
return null;
}
}

10
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecShulkerBox.java
View File

@ -4,9 +4,7 @@ import static de.diddiz.LogBlock.config.Config.getWorldConfig;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.ShulkerBox;
@ -16,7 +14,7 @@ import org.bukkit.inventory.ItemStack;
public class BlockStateCodecShulkerBox implements BlockStateCodec {
@Override
public Material[] getApplicableMaterials() {
return BukkitUtils.getShulkerBoxBlocks().toArray(Material[]::new);
return BukkitUtils.getShulkerBoxBlocks().toArray(new Material[BukkitUtils.getShulkerBoxBlocks().size()]);
}
@Override
@ -62,7 +60,7 @@ public class BlockStateCodecShulkerBox implements BlockStateCodec {
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState) {
public String toString(YamlConfiguration conf) {
if (conf != null) {
StringBuilder sb = new StringBuilder();
sb.append("[");
@ -80,7 +78,7 @@ public class BlockStateCodecShulkerBox implements BlockStateCodec {
}
}
sb.append("]");
return anySlot ? new TextComponent(sb.toString()) : null;
return anySlot ? sb.toString() : null;
}
return null;
}

233
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecSign.java
View File

@ -1,88 +1,57 @@
package de.diddiz.LogBlock.blockstate;
import de.diddiz.LogBlock.util.BukkitUtils;
import java.awt.Color;
import de.diddiz.util.BukkitUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.block.sign.Side;
import org.bukkit.block.sign.SignSide;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
public class BlockStateCodecSign implements BlockStateCodec {
@Override
public Material[] getApplicableMaterials() {
return BukkitUtils.getAllSignMaterials().toArray(Material[]::new);
return BukkitUtils.getAllSignsArray();
}
@Override
public YamlConfiguration serialize(BlockState state) {
YamlConfiguration conf = null;
if (state instanceof Sign sign) {
boolean waxed = sign.isWaxed();
if (waxed) {
conf = new YamlConfiguration();
conf.set("waxed", waxed);
if (state instanceof Sign) {
Sign sign = (Sign) state;
String[] lines = sign.getLines();
boolean hasText = false;
for (int i = 0; i < lines.length; i++) {
if (lines[i] != null && lines[i].length() > 0) {
hasText = true;
break;
}
}
for (Side side : Side.values()) {
SignSide signSide = sign.getSide(side);
String[] lines = signSide.getLines();
boolean hasText = false;
for (int i = 0; i < lines.length; i++) {
if (lines[i] != null && lines[i].length() > 0) {
hasText = true;
break;
}
DyeColor signColor = sign.getColor();
if (signColor == null) {
signColor = DyeColor.BLACK;
}
if (hasText || signColor != DyeColor.BLACK) {
YamlConfiguration conf = new YamlConfiguration();
if (hasText) {
conf.set("lines", Arrays.asList(lines));
}
DyeColor signColor = signSide.getColor();
if (signColor == null) {
signColor = DyeColor.BLACK;
}
boolean glowing = signSide.isGlowingText();
if (hasText || signColor != DyeColor.BLACK || glowing) {
if (conf == null) {
conf = new YamlConfiguration();
}
ConfigurationSection sideSection = side == Side.FRONT ? conf : conf.createSection(side.name().toLowerCase());
if (hasText) {
sideSection.set("lines", Arrays.asList(lines));
}
if (signColor != DyeColor.BLACK) {
sideSection.set("color", signColor.name());
}
if (glowing) {
sideSection.set("glowing", true);
}
if (signColor != DyeColor.BLACK) {
conf.set("color", signColor.name());
}
return conf;
}
}
return conf;
return null;
}
/**
* This is required for the SignChangeEvent, because we have no updated BlockState there.
* @param state
* This is required for the SignChangeEvent, because we have no BlockState there.
*/
public YamlConfiguration serialize(BlockState state, Side side, String[] lines) {
YamlConfiguration conf = state == null ? null : serialize(state);
if (lines != null) {
if (conf == null) {
conf = new YamlConfiguration();
}
ConfigurationSection sideSection = side == Side.FRONT ? conf : conf.getConfigurationSection(side.name().toLowerCase());
if (sideSection == null) {
sideSection = conf.createSection(side.name().toLowerCase());
}
sideSection.set("lines", Arrays.asList(lines));
}
public static YamlConfiguration serialize(String[] lines) {
YamlConfiguration conf = new YamlConfiguration();
conf.set("lines", Arrays.asList(lines));
return conf;
}
@ -90,138 +59,40 @@ public class BlockStateCodecSign implements BlockStateCodec {
public void deserialize(BlockState state, YamlConfiguration conf) {
if (state instanceof Sign) {
Sign sign = (Sign) state;
DyeColor signColor = DyeColor.BLACK;
List<String> lines = Collections.emptyList();
if (conf != null) {
sign.setWaxed(conf.getBoolean("waxed"));
for (Side side : Side.values()) {
ConfigurationSection sideSection = side == Side.FRONT ? conf : conf.getConfigurationSection(side.name().toLowerCase());
DyeColor signColor = DyeColor.BLACK;
boolean glowing = false;
List<String> lines = Collections.emptyList();
if (sideSection != null) {
if (sideSection.contains("lines")) {
lines = sideSection.getStringList("lines");
}
if (sideSection.contains("color")) {
try {
signColor = DyeColor.valueOf(sideSection.getString("color"));
} catch (IllegalArgumentException | NullPointerException e) {
// ignored
}
}
glowing = sideSection.getBoolean("glowing", false);
}
SignSide signSide = sign.getSide(side);
for (int i = 0; i < 4; i++) {
String line = lines.size() > i && lines.get(i) != null ? lines.get(i) : "";
signSide.setLine(i, line);
}
signSide.setColor(signColor);
signSide.setGlowingText(glowing);
if (conf.contains("lines")) {
lines = conf.getStringList("lines");
}
} else {
sign.setWaxed(false);
for (Side side : Side.values()) {
SignSide signSide = sign.getSide(side);
for (int i = 0; i < 4; i++) {
signSide.setLine(i, "");
}
signSide.setColor(DyeColor.BLACK);
signSide.setGlowingText(false);
}
}
}
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration state, YamlConfiguration oldState) {
if (state != null) {
TextComponent tc = new TextComponent();
// StringBuilder sb = new StringBuilder();
boolean isWaxed = state.getBoolean("waxed");
boolean oldWaxed = oldState != null && oldState.getBoolean("waxed");
if (isWaxed != oldWaxed) {
tc.addExtra(isWaxed ? "(waxed)" : "(not waxed)");
}
for (Side side : Side.values()) {
boolean sideHeaderAdded = false;
ConfigurationSection sideSection = side == Side.FRONT ? state : state.getConfigurationSection(side.name().toLowerCase());
List<String> lines = sideSection == null ? Collections.emptyList() : sideSection.getStringList("lines");
List<String> oldLines = Collections.emptyList();
DyeColor signColor = DyeColor.BLACK;
if (sideSection != null && sideSection.contains("color")) {
if (conf.contains("color")) {
try {
signColor = DyeColor.valueOf(sideSection.getString("color"));
signColor = DyeColor.valueOf(conf.getString("color"));
} catch (IllegalArgumentException | NullPointerException e) {
// ignored
}
}
DyeColor oldSignColor = DyeColor.BLACK;
boolean glowing = sideSection != null && sideSection.getBoolean("glowing", false);
boolean oldGlowing = false;
if (oldState != null) {
ConfigurationSection oldSideSection = side == Side.FRONT ? oldState : oldState.getConfigurationSection(side.name().toLowerCase());
if (oldSideSection != null) {
oldLines = oldSideSection.getStringList("lines");
if (oldSideSection.contains("color")) {
try {
oldSignColor = DyeColor.valueOf(oldSideSection.getString("color"));
} catch (IllegalArgumentException | NullPointerException e) {
// ignored
}
}
oldGlowing = oldSideSection.getBoolean("glowing", false);
}
}
if (!lines.equals(oldLines)) {
sideHeaderAdded = addSideHeaderText(tc, side, sideHeaderAdded);
for (String line : lines) {
if (tc.getExtra() != null && !tc.getExtra().isEmpty()) {
tc.addExtra(" ");
}
tc.addExtra("[");
if (line != null && !line.isEmpty()) {
tc.addExtra(new TextComponent(TextComponent.fromLegacyText(line)));
}
tc.addExtra("]");
}
}
if (signColor != oldSignColor) {
sideHeaderAdded = addSideHeaderText(tc, side, sideHeaderAdded);
if (tc.getExtra() != null && !tc.getExtra().isEmpty()) {
tc.addExtra(" ");
}
tc.addExtra("(color: ");
TextComponent colorText = new TextComponent(signColor.name().toLowerCase());
colorText.setColor(ChatColor.of(new Color(signColor.getColor().asARGB())));
tc.addExtra(colorText);
tc.addExtra(")");
}
if (glowing != oldGlowing) {
sideHeaderAdded = addSideHeaderText(tc, side, sideHeaderAdded);
if (tc.getExtra() != null && !tc.getExtra().isEmpty()) {
tc.addExtra(" ");
}
if (glowing) {
tc.addExtra("(glowing)");
} else {
tc.addExtra("(not glowing)");
}
}
}
return tc;
for (int i = 0; i < 4; i++) {
String line = lines.size() > i && lines.get(i) != null ? lines.get(i) : "";
sign.setLine(i, line);
}
sign.setColor(signColor);
}
}
@Override
public String toString(YamlConfiguration conf) {
if (conf != null) {
StringBuilder sb = new StringBuilder();
for (String line : conf.getStringList("lines")) {
if (sb.length() > 0) {
sb.append(" ");
}
sb.append("[").append(line).append("]");
}
return sb.toString();
}
return null;
}
private static boolean addSideHeaderText(TextComponent tc, Side side, boolean wasAdded) {
if (!wasAdded) {
if (tc.getExtra() != null && !tc.getExtra().isEmpty()) {
tc.addExtra(" ");
}
tc.addExtra(side.name() + ":");
}
return true;
}
}

56
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecSkull.java
View File

@ -1,30 +1,15 @@
package de.diddiz.LogBlock.blockstate;
import java.util.UUID;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.HoverEvent;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.chat.hover.content.Text;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.block.BlockState;
import org.bukkit.block.Skull;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.profile.PlayerProfile;
public class BlockStateCodecSkull implements BlockStateCodec {
private static final boolean HAS_PROFILE_API;
static {
boolean hasProfileApi = false;
try {
Skull.class.getMethod("getOwnerProfile");
hasProfileApi = true;
} catch (NoSuchMethodException ignored) {
}
HAS_PROFILE_API = hasProfileApi;
}
@Override
public Material[] getApplicableMaterials() {
return new Material[] { Material.PLAYER_WALL_HEAD, Material.PLAYER_HEAD };
@ -35,14 +20,9 @@ public class BlockStateCodecSkull implements BlockStateCodec {
if (state instanceof Skull) {
Skull skull = (Skull) state;
OfflinePlayer owner = skull.hasOwner() ? skull.getOwningPlayer() : null;
PlayerProfile profile = HAS_PROFILE_API ? skull.getOwnerProfile() : null;
if (owner != null || profile != null) {
if (owner != null) {
YamlConfiguration conf = new YamlConfiguration();
if (profile != null) {
conf.set("profile", profile);
} else if (owner != null) {
conf.set("owner", owner.getUniqueId().toString());
}
conf.set("owner", owner.getUniqueId().toString());
return conf;
}
}
@ -53,37 +33,21 @@ public class BlockStateCodecSkull implements BlockStateCodec {
public void deserialize(BlockState state, YamlConfiguration conf) {
if (state instanceof Skull) {
Skull skull = (Skull) state;
PlayerProfile profile = conf == null || !HAS_PROFILE_API ? null : (PlayerProfile) conf.get("profile");
if (profile != null) {
skull.setOwnerProfile(profile);
UUID ownerId = conf == null ? null : UUID.fromString(conf.getString("owner"));
if (ownerId == null) {
skull.setOwningPlayer(null);
} else {
UUID ownerId = conf == null ? null : UUID.fromString(conf.getString("owner"));
if (ownerId == null) {
skull.setOwningPlayer(null);
} else {
skull.setOwningPlayer(Bukkit.getOfflinePlayer(ownerId));
}
skull.setOwningPlayer(Bukkit.getOfflinePlayer(ownerId));
}
}
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState) {
if (HAS_PROFILE_API && conf != null) {
PlayerProfile profile = (PlayerProfile) conf.get("profile");
if (profile != null) {
TextComponent tc = new TextComponent("[" + (profile.getName() != null ? profile.getName() : (profile.getUniqueId() != null ? profile.getUniqueId().toString() : "~unknown~")) + "]");
if (profile.getName() != null && profile.getUniqueId() != null) {
tc.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text("UUID: " + profile.getUniqueId().toString())));
}
return tc;
}
}
String ownerIdString = conf == null ? null : conf.getString("owner");
UUID ownerId = ownerIdString == null ? null : UUID.fromString(ownerIdString);
public String toString(YamlConfiguration conf) {
UUID ownerId = conf == null ? null : UUID.fromString(conf.getString("owner"));
if (ownerId != null) {
OfflinePlayer owner = Bukkit.getOfflinePlayer(ownerId);
return new TextComponent("[" + (owner.getName() != null ? owner.getName() : owner.getUniqueId().toString()) + "]");
return "[" + (owner.getName() != null ? owner.getName() : owner.getUniqueId().toString()) + "]";
}
return null;
}

22
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecSpawner.java
View File

@ -1,8 +1,5 @@
package de.diddiz.LogBlock.blockstate;
import de.diddiz.LogBlock.LogBlock;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.CreatureSpawner;
@ -26,9 +23,7 @@ public class BlockStateCodecSpawner implements BlockStateCodec {
conf.set("minSpawnDelay", spawner.getMinSpawnDelay());
conf.set("requiredPlayerRange", spawner.getRequiredPlayerRange());
conf.set("spawnCount", spawner.getSpawnCount());
if (spawner.getSpawnedType() != null) {
conf.set("spawnedType", spawner.getSpawnedType().name());
}
conf.set("spawnedType", spawner.getSpawnedType().name());
conf.set("spawnRange", spawner.getSpawnRange());
return conf;
}
@ -46,27 +41,18 @@ public class BlockStateCodecSpawner implements BlockStateCodec {
spawner.setMinSpawnDelay(conf.getInt("minSpawnDelay"));
spawner.setRequiredPlayerRange(conf.getInt("requiredPlayerRange"));
spawner.setSpawnCount(conf.getInt("spawnCount"));
EntityType spawnedType = null;
String spawnedTypeString = conf.getString("spawnedType");
if (spawnedTypeString != null) {
try {
spawnedType = EntityType.valueOf(spawnedTypeString);
} catch (IllegalArgumentException ignored) {
LogBlock.getInstance().getLogger().warning("Could not find spawner spawned type: " + spawnedTypeString);
}
}
spawner.setSpawnedType(spawnedType);
spawner.setSpawnedType(EntityType.valueOf(conf.getString("spawnedType")));
spawner.setSpawnRange(conf.getInt("spawnRange"));
}
}
}
@Override
public BaseComponent getChangesAsComponent(YamlConfiguration conf, YamlConfiguration oldState) {
public String toString(YamlConfiguration conf) {
if (conf != null) {
EntityType entity = EntityType.valueOf(conf.getString("spawnedType"));
if (entity != null) {
return new TextComponent("[" + entity.getKey().getKey() + "]");
return "[" + entity + "]";
}
}
return null;

10
src/main/java/de/diddiz/LogBlock/blockstate/BlockStateCodecs.java
View File

@ -1,14 +1,14 @@
package de.diddiz.LogBlock.blockstate;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Map;
import net.md_5.bungee.api.chat.BaseComponent;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.configuration.file.YamlConfiguration;
public class BlockStateCodecs {
private static Map<Material, BlockStateCodec> codecs = new HashMap<>();
private static Map<Material, BlockStateCodec> codecs = new EnumMap<>(Material.class);
public static void registerCodec(BlockStateCodec codec) {
Material[] materials = codec.getApplicableMaterials();
@ -51,10 +51,10 @@ public class BlockStateCodecs {
}
}
public static BaseComponent getChangesAsComponent(Material material, YamlConfiguration state, YamlConfiguration oldState) {
public static String toString(Material material, YamlConfiguration state) {
BlockStateCodec codec = codecs.get(material);
if (codec != null) {
return codec.getChangesAsComponent(state, oldState);
return codec.toString(state);
}
return null;
}

29
src/main/java/de/diddiz/LogBlock/config/Config.java
View File

@ -1,7 +1,8 @@
package de.diddiz.LogBlock.config;
import de.diddiz.LogBlock.*;
import de.diddiz.LogBlock.util.ComparableVersion;
import de.diddiz.util.ComparableVersion;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.configuration.ConfigurationSection;
@ -16,8 +17,8 @@ import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.zip.DataFormatException;
import static de.diddiz.LogBlock.util.BukkitUtils.friendlyWorldname;
import static de.diddiz.LogBlock.util.Utils.parseTimeSpec;
import static de.diddiz.util.BukkitUtils.friendlyWorldname;
import static de.diddiz.util.Utils.parseTimeSpec;
import static org.bukkit.Bukkit.*;
public class Config {
@ -28,6 +29,7 @@ public class Config {
public static boolean mysqlUseSSL;
public static boolean mysqlRequireSSL;
public static int delayBetweenRuns, forceToProcessAtLeast, timePerRun;
public static boolean fireCustomEvents;
public static boolean useBukkitScheduler;
public static int queueWarningSize;
public static boolean enableAutoClearLog;
@ -52,14 +54,13 @@ public class Config {
public static List<String> ignoredChat;
public static SimpleDateFormat formatter;
public static SimpleDateFormat formatterShort;
public static boolean safetyIdCheck;
public static boolean debug;
public static boolean logEnvironmentalKills;
// addons
public static boolean worldGuardLoggingFlags;
// Not loaded from config - checked at runtime
public static boolean mb4 = false;
public static final String CURRENT_CONFIG_VERSION = "1.19.0";
public static final String CURRENT_CONFIG_VERSION = "1.16.0";
public static enum LogKillsLevel {
PLAYERS,
@ -81,7 +82,6 @@ public class Config {
worldNames.add("world_the_end");
}
def.put("loggedWorlds", worldNames);
def.put("mysql.protocol", "mysql");
def.put("mysql.host", "localhost");
def.put("mysql.port", 3306);
def.put("mysql.database", "minecraft");
@ -92,6 +92,7 @@ public class Config {
def.put("consumer.delayBetweenRuns", 2);
def.put("consumer.forceToProcessAtLeast", 200);
def.put("consumer.timePerRun", 1000);
def.put("consumer.fireCustomEvents", false);
def.put("consumer.useBukkitScheduler", true);
def.put("consumer.queueWarningSize", 1000);
def.put("clearlog.dumpDeletedLog", false);
@ -164,23 +165,19 @@ public class Config {
def.put("tools.toolblock.mode", "LOOKUP");
def.put("tools.toolblock.permissionDefault", "OP");
def.put("safety.id.check", true);
def.put("addons.worldguardLoggingFlags", false);
def.put("debug", false);
for (final Entry<String, Object> e : def.entrySet()) {
if (!config.contains(e.getKey())) {
config.set(e.getKey(), e.getValue());
}
}
if (config.contains("consumer.fireCustomEvents")) {
config.set("consumer.fireCustomEvents", null);
}
logblock.saveConfig();
ComparableVersion configVersion = new ComparableVersion(config.getString("version"));
boolean oldConfig = configVersion.compareTo(new ComparableVersion(CURRENT_CONFIG_VERSION)) < 0;
mysqlDatabase = getStringIncludingInts(config, "mysql.database");
url = "jdbc:" + config.getString("mysql.protocol") + "://" + config.getString("mysql.host") + ":" + config.getInt("mysql.port") + "/" + mysqlDatabase;
url = "jdbc:mysql://" + config.getString("mysql.host") + ":" + config.getInt("mysql.port") + "/" + mysqlDatabase;
user = getStringIncludingInts(config, "mysql.user");
password = getStringIncludingInts(config, "mysql.password");
mysqlUseSSL = config.getBoolean("mysql.useSSL", true);
@ -188,6 +185,7 @@ public class Config {
delayBetweenRuns = config.getInt("consumer.delayBetweenRuns", 2);
forceToProcessAtLeast = config.getInt("consumer.forceToProcessAtLeast", 0);
timePerRun = config.getInt("consumer.timePerRun", 1000);
fireCustomEvents = config.getBoolean("consumer.fireCustomEvents", false);
useBukkitScheduler = config.getBoolean("consumer.useBukkitScheduler", true);
queueWarningSize = config.getInt("consumer.queueWarningSize", 1000);
enableAutoClearLog = config.getBoolean("clearlog.enableAutoClearLog");
@ -252,6 +250,7 @@ public class Config {
askClearLogs = config.getBoolean("questioner.askClearLogs", true);
askClearLogAfterRollback = config.getBoolean("questioner.askClearLogAfterRollback", true);
askRollbackAfterBan = config.getBoolean("questioner.askRollbackAfterBan", false);
safetyIdCheck = config.getBoolean("safety.id.check", true);
debug = config.getBoolean("debug", false);
banPermission = config.getString("questioner.banPermission");
final List<Tool> tools = new ArrayList<>();
@ -286,7 +285,6 @@ public class Config {
toolsByName.put(alias, tool);
}
}
worldGuardLoggingFlags = config.getBoolean("addons.worldguardLoggingFlags");
final List<String> loggedWorlds = config.getStringList("loggedWorlds");
worldConfigs = new HashMap<>();
if (loggedWorlds.isEmpty()) {
@ -359,11 +357,6 @@ public class Config {
}
return false;
}
public static boolean isLoggingNatualSpawns(World world) {
final WorldConfig wcfg = worldConfigs.get(world.getName());
return wcfg != null && wcfg.logNaturalEntitySpawns;
}
}
class LoggingEnabledMapping {

4
src/main/java/de/diddiz/LogBlock/config/EntityLogging.java
View File

@ -7,8 +7,8 @@ import java.util.List;
import org.bukkit.entity.EntityType;
public enum EntityLogging {
SPAWN(new String[] { EntityType.ARMOR_STAND.name(), EntityType.ITEM_FRAME.name(), EntityType.SNOWMAN.name() }),
DESTROY(new String[] { EntityType.ARMOR_STAND.name(), EntityType.ITEM_FRAME.name(), EntityType.VILLAGER.name(), EntityType.SNOWMAN.name(), "ANIMAL" }),
SPAWN(new String[] { EntityType.ARMOR_STAND.name(), EntityType.ITEM_FRAME.name(), EntityType.IRON_GOLEM.name(), EntityType.SNOWMAN.name() }),
DESTROY(new String[] { EntityType.ARMOR_STAND.name(), EntityType.ITEM_FRAME.name(), EntityType.VILLAGER.name(), EntityType.IRON_GOLEM.name(), EntityType.SNOWMAN.name(), "ANIMAL" }),
MODIFY(new String[] { "ALL" });
public static final int length = EntityLogging.values().length;

318
src/main/java/de/diddiz/LogBlock/config/WorldConfig.java
View File

@ -1,171 +1,147 @@
package de.diddiz.LogBlock.config;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.util.BukkitUtils;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Animals;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Monster;
import org.bukkit.entity.Player;
import org.bukkit.entity.WaterMob;
import java.io.File;
import java.io.IOException;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
public class WorldConfig extends LoggingEnabledMapping {
public final String world;
public final String table;
public final String insertBlockStatementString;
public final String selectBlockActorIdStatementString;
public final String insertBlockStateStatementString;
public final String insertBlockChestDataStatementString;
public final String insertEntityStatementString;
public final String updateEntityUUIDString;
private final EnumMap<EntityLogging, EntityLoggingList> entityLogging = new EnumMap<>(EntityLogging.class);
public final boolean logNaturalEntitySpawns;
public final boolean logAllNamedEntityKills;
public WorldConfig(String world, File file) throws IOException {
this.world = world;
final Map<String, Object> def = new HashMap<>();
// "Before MySQL 5.1.6, database and table names cannot contain "/", "\", ".", or characters that are not permitted in file names" - MySQL manual
// They _can_ contain spaces, but replace them as well
def.put("table", "lb-" + file.getName().substring(0, file.getName().length() - 4).replaceAll("[ ./\\\\]", "_"));
for (final Logging l : Logging.values()) {
def.put("logging." + l.toString(), l.isDefaultEnabled());
}
final YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
for (final Entry<String, Object> e : def.entrySet()) {
if (config.get(e.getKey()) == null) {
config.set(e.getKey(), e.getValue());
}
}
for (EntityLogging el : EntityLogging.values()) {
if (!(config.get("entity." + el.name().toLowerCase()) instanceof List)) {
config.set("entity." + el.name().toLowerCase(), el.getDefaultEnabled());
}
entityLogging.put(el, new EntityLoggingList(el, config.getStringList("entity." + el.name().toLowerCase())));
}
if (!config.isBoolean("entity.logNaturalSpawns")) {
config.set("entity.logNaturalSpawns", false);
}
logNaturalEntitySpawns = config.getBoolean("entity.logNaturalSpawns");
if (!config.isBoolean("entity.logAllNamedEntityKills")) {
config.set("entity.logAllNamedEntityKills", true);
}
logAllNamedEntityKills = config.getBoolean("entity.logAllNamedEntityKills");
config.save(file);
table = config.getString("table");
for (final Logging l : Logging.values()) {
setLogging(l, config.getBoolean("logging." + l.toString()));
}
insertBlockStatementString = "INSERT INTO `" + table + "-blocks` (date, playerid, replaced, replaceddata, type, typedata, x, y, z) VALUES (FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?)";
selectBlockActorIdStatementString = "SELECT playerid FROM `" + table + "-blocks` WHERE x = ? AND y = ? AND z = ? ORDER BY date DESC LIMIT 1";
insertBlockStateStatementString = "INSERT INTO `" + table + "-state` (replacedState, typeState, id) VALUES(?, ?, ?)";
insertBlockChestDataStatementString = "INSERT INTO `" + table + "-chestdata` (item, itemremove, id, itemtype) values (?, ?, ?, ?)";
insertEntityStatementString = "INSERT INTO `" + table + "-entities` (date, playerid, entityid, entitytypeid, x, y, z, action, data) VALUES (FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?)";
updateEntityUUIDString = "UPDATE `" + table + "-entityids` SET entityuuid = ? WHERE entityid = ?";
}
public boolean isLogging(EntityLogging logging, Entity entity) {
return entityLogging.get(logging).isLogging(entity);
}
public boolean isLoggingAnyEntities() {
for (EntityLoggingList list : entityLogging.values()) {
if (list.isLoggingAnyEntities()) {
return true;
}
}
return false;
}
private class EntityLoggingList {
private final EntityLogging entityAction;
private final HashSet<EntityType> logged = new HashSet<>();
private final boolean logAll;
private final boolean logAnimals;
private final boolean logWateranimals;
private final boolean logMonsters;
private final boolean logLiving;
public EntityLoggingList(EntityLogging entityAction, List<String> types) {
this.entityAction = entityAction;
boolean all = false;
boolean animals = false;
boolean wateranimals = false;
boolean monsters = false;
boolean living = false;
for (String type : types) {
EntityType et = BukkitUtils.matchEntityType(type);
if (et != null) {
logged.add(et);
} else {
if (type.equalsIgnoreCase("all")) {
all = true;
} else if (type.equalsIgnoreCase("animal") || type.equalsIgnoreCase("animals")) {
animals = true;
} else if (type.equalsIgnoreCase("wateranimal") || type.equalsIgnoreCase("wateranimals")) {
wateranimals = true;
} else if (type.equalsIgnoreCase("monster") || type.equalsIgnoreCase("monsters")) {
monsters = true;
} else if (type.equalsIgnoreCase("living")) {
living = true;
} else {
LogBlock.getInstance().getLogger().log(Level.WARNING, "Unkown entity type in config for " + world + ": " + type);
}
}
}
logAll = all;
logAnimals = animals;
logWateranimals = wateranimals;
logMonsters = monsters;
logLiving = living;
}
public boolean isLogging(Entity entity) {
if (entity == null || (entity instanceof Player)) {
return false;
}
EntityType type = entity.getType();
if (logAll || logged.contains(type)) {
return true;
}
if (logLiving && LivingEntity.class.isAssignableFrom(entity.getClass()) && !(entity instanceof ArmorStand)) {
return true;
}
if (logAnimals && Animals.class.isAssignableFrom(entity.getClass())) {
return true;
}
if (logWateranimals && WaterMob.class.isAssignableFrom(entity.getClass())) {
return true;
}
if (logMonsters && (Monster.class.isAssignableFrom(entity.getClass()) || entity.getType() == EntityType.SLIME || entity.getType() == EntityType.WITHER || entity.getType() == EntityType.ENDER_DRAGON || entity.getType() == EntityType.SHULKER || entity.getType() == EntityType.GHAST)) {
return true;
}
if (entityAction == EntityLogging.DESTROY && logAllNamedEntityKills && entity.getCustomName() != null) {
return true;
}
return false;
}
public boolean isLoggingAnyEntities() {
return logAll || logAnimals || logLiving || logMonsters || !logged.isEmpty() || (entityAction == EntityLogging.DESTROY && logAllNamedEntityKills);
}
}
}
package de.diddiz.LogBlock.config;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.util.BukkitUtils;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Animals;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Monster;
import org.bukkit.entity.Player;
import org.bukkit.entity.WaterMob;
import java.io.File;
import java.io.IOException;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
public class WorldConfig extends LoggingEnabledMapping {
public final String world;
public final String table;
public final String insertBlockStatementString;
public final String selectBlockActorIdStatementString;
public final String insertBlockStateStatementString;
public final String insertBlockChestDataStatementString;
public final String insertEntityStatementString;
public final String updateEntityUUIDString;
private final EnumMap<EntityLogging, EntityLoggingList> entityLogging = new EnumMap<>(EntityLogging.class);
public WorldConfig(String world, File file) throws IOException {
this.world = world;
final Map<String, Object> def = new HashMap<>();
// "Before MySQL 5.1.6, database and table names cannot contain "/", "\", ".", or characters that are not permitted in file names" - MySQL manual
// They _can_ contain spaces, but replace them as well
def.put("table", "lb-" + file.getName().substring(0, file.getName().length() - 4).replaceAll("[ ./\\\\]", "_"));
for (final Logging l : Logging.values()) {
def.put("logging." + l.toString(), l.isDefaultEnabled());
}
final YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
for (final Entry<String, Object> e : def.entrySet()) {
if (config.get(e.getKey()) == null) {
config.set(e.getKey(), e.getValue());
}
}
for (EntityLogging el : EntityLogging.values()) {
if (!(config.get("entity." + el.name().toLowerCase()) instanceof List)) {
config.set("entity." + el.name().toLowerCase(), el.getDefaultEnabled());
}
entityLogging.put(el, new EntityLoggingList(config.getStringList("entity." + el.name().toLowerCase())));
}
config.save(file);
table = config.getString("table");
for (final Logging l : Logging.values()) {
setLogging(l, config.getBoolean("logging." + l.toString()));
}
insertBlockStatementString = "INSERT INTO `" + table + "-blocks` (date, playerid, replaced, replaceddata, type, typedata, x, y, z) VALUES (FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?)";
selectBlockActorIdStatementString = "SELECT playerid FROM `" + table + "-blocks` WHERE x = ? AND y = ? AND z = ? ORDER BY date DESC LIMIT 1";
insertBlockStateStatementString = "INSERT INTO `" + table + "-state` (replacedState, typeState, id) VALUES(?, ?, ?)";
insertBlockChestDataStatementString = "INSERT INTO `" + table + "-chestdata` (item, itemremove, id, itemtype) values (?, ?, ?, ?)";
insertEntityStatementString = "INSERT INTO `" + table + "-entities` (date, playerid, entityid, entitytypeid, x, y, z, action, data) VALUES (FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?)";
updateEntityUUIDString = "UPDATE `" + table + "-entityids` SET entityuuid = ? WHERE entityid = ?";
}
public boolean isLogging(EntityLogging logging, Entity entity) {
return entityLogging.get(logging).isLogging(entity);
}
public boolean isLoggingAnyEntities() {
for (EntityLoggingList list : entityLogging.values()) {
if (list.isLoggingAnyEntities()) {
return true;
}
}
return false;
}
private class EntityLoggingList {
private final EnumSet<EntityType> logged = EnumSet.noneOf(EntityType.class);
private final boolean logAll;
private final boolean logAnimals;
private final boolean logMonsters;
private final boolean logLiving;
public EntityLoggingList(List<String> types) {
boolean all = false;
boolean animals = false;
boolean monsters = false;
boolean living = false;
for (String type : types) {
EntityType et = BukkitUtils.matchEntityType(type);
if (et != null) {
logged.add(et);
} else {
if (type.equalsIgnoreCase("all")) {
all = true;
} else if (type.equalsIgnoreCase("animal") || type.equalsIgnoreCase("animals")) {
animals = true;
} else if (type.equalsIgnoreCase("monster") || type.equalsIgnoreCase("monsters")) {
monsters = true;
} else if (type.equalsIgnoreCase("living")) {
living = true;
} else {
LogBlock.getInstance().getLogger().log(Level.WARNING, "Unkown entity type in config for " + world + ": " + type);
}
}
}
logAll = all;
logAnimals = animals;
logMonsters = monsters;
logLiving = living;
}
public boolean isLogging(Entity entity) {
if (entity == null || (entity instanceof Player)) {
return false;
}
EntityType type = entity.getType();
if (logAll || logged.contains(type)) {
return true;
}
if (logLiving && LivingEntity.class.isAssignableFrom(entity.getClass()) && !(entity instanceof ArmorStand)) {
return true;
}
if (logAnimals && (Animals.class.isAssignableFrom(entity.getClass()) || WaterMob.class.isAssignableFrom(entity.getClass()))) {
return true;
}
if (logMonsters && (Monster.class.isAssignableFrom(entity.getClass()) || entity.getType() == EntityType.SLIME || entity.getType() == EntityType.WITHER || entity.getType() == EntityType.ENDER_DRAGON || entity.getType() == EntityType.SHULKER || entity.getType() == EntityType.GHAST)) {
return true;
}
return false;
}
public boolean isLoggingAnyEntities() {
return logAll || logAnimals || logLiving || logMonsters || !logged.isEmpty();
}
}
}

54
src/main/java/de/diddiz/LogBlock/events/EntityChangePreLogEvent.java
View File

@ -1,54 +0,0 @@
package de.diddiz.LogBlock.events;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.EntityChange.EntityChangeType;
import org.bukkit.Location;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Entity;
import org.bukkit.event.HandlerList;
public class EntityChangePreLogEvent extends PreLogEvent {
private static final HandlerList handlers = new HandlerList();
private Location location;
private Entity entity;
private EntityChangeType changeType;
private YamlConfiguration changeData;
public EntityChangePreLogEvent(Actor owner, Location location, Entity entity, EntityChangeType changeType, YamlConfiguration changeData) {
super(owner);
this.location = location;
this.entity = entity;
this.changeType = changeType;
this.changeData = changeData;
}
public Location getLocation() {
return location;
}
public void setLocation(Location location) {
this.location = location;
}
public Entity getEntity() {
return entity;
}
public EntityChangeType getChangeType() {
return changeType;
}
public YamlConfiguration getChangeData() {
return changeData;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

60
src/main/java/de/diddiz/LogBlock/listeners/AdvancedEntityLogging.java
View File

@ -6,9 +6,7 @@ import org.bukkit.block.BlockFace;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Bee;
import org.bukkit.entity.EnderCrystal;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Hanging;
import org.bukkit.entity.IronGolem;
import org.bukkit.entity.ItemFrame;
@ -25,7 +23,6 @@ import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityPlaceEvent;
import org.bukkit.event.hanging.HangingBreakByEntityEvent;
import org.bukkit.event.hanging.HangingBreakEvent;
import org.bukkit.event.hanging.HangingPlaceEvent;
@ -42,8 +39,8 @@ import de.diddiz.LogBlock.EntityChange.EntityChangeType;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.EntityLogging;
import de.diddiz.LogBlock.util.LoggingUtil;
import de.diddiz.LogBlock.worldedit.WorldEditHelper;
import de.diddiz.util.LoggingUtil;
import de.diddiz.worldedit.WorldEditHelper;
import java.util.UUID;
public class AdvancedEntityLogging extends LoggingListener {
@ -55,7 +52,6 @@ public class AdvancedEntityLogging extends LoggingListener {
// serialize them before the death event
private UUID lastEntityDamagedForDeathUUID;
private byte[] lastEntityDamagedForDeathSerialized;
private Entity lastEntityDamagedForDeathDamager;
public AdvancedEntityLogging(LogBlock lb) {
super(lb);
@ -73,7 +69,6 @@ public class AdvancedEntityLogging extends LoggingListener {
lastSpawnerEgg = false;
lastEntityDamagedForDeathUUID = null;
lastEntityDamagedForDeathSerialized = null;
lastEntityDamagedForDeathDamager = null;
}
private void setLastSpawner(Player player, Class<? extends Entity> spawning, boolean spawnEgg) {
@ -131,7 +126,7 @@ public class AdvancedEntityLogging extends LoggingListener {
inHand = inHand.clone();
inHand.setAmount(1);
data.set("item", inHand);
consumer.queueEntityModification(actor, entity, EntityChange.EntityChangeType.ADDEQUIP, data);
consumer.queueEntityModification(actor, entity.getUniqueId(), entity.getType(), entity.getLocation(), EntityChange.EntityChangeType.ADDEQUIP, data);
}
}
}
@ -144,10 +139,6 @@ public class AdvancedEntityLogging extends LoggingListener {
if (event.getSpawnReason() == SpawnReason.CUSTOM || event.getSpawnReason() == SpawnReason.BEEHIVE) {
return;
}
if (event.getEntityType() == EntityType.ARMOR_STAND) {
resetOnTick();
return; // logged in the method below
}
LivingEntity entity = event.getEntity();
if (Config.isLogging(entity.getWorld(), EntityLogging.SPAWN, entity)) {
Actor actor = null;
@ -159,9 +150,6 @@ public class AdvancedEntityLogging extends LoggingListener {
}
}
if (actor == null) {
if (event.getSpawnReason() == SpawnReason.NATURAL && !Config.isLoggingNatualSpawns(entity.getWorld())) {
return;
}
actor = new Actor(event.getSpawnReason().toString());
}
queueEntitySpawnOrKill(entity, actor, EntityChange.EntityChangeType.CREATE);
@ -170,23 +158,6 @@ public class AdvancedEntityLogging extends LoggingListener {
resetOnTick();
}
@EventHandler(priority = EventPriority.MONITOR)
public void onEntityPlace(EntityPlaceEvent event) {
if (!event.isCancelled()) {
Entity entity = event.getEntity();
if (Config.isLogging(entity.getWorld(), EntityLogging.SPAWN, entity)) {
Actor actor = null;
if (event.getPlayer() != null) {
actor = Actor.actorFromEntity(event.getPlayer());
}
if (actor == null) {
actor = new Actor("UNKNOWN");
}
queueEntitySpawnOrKill(entity, actor, EntityChange.EntityChangeType.CREATE);
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent event) {
LivingEntity entity = event.getEntity();
@ -199,9 +170,6 @@ public class AdvancedEntityLogging extends LoggingListener {
actor = Actor.actorFromEntity(damager);
}
}
if (actor == null && entity.getKiller() != null) {
actor = Actor.actorFromEntity(entity.getKiller());
}
if (actor == null) {
actor = new Actor(lastDamage == null ? "UNKNOWN" : lastDamage.getCause().toString());
}
@ -249,7 +217,7 @@ public class AdvancedEntityLogging extends LoggingListener {
}
YamlConfiguration data = new YamlConfiguration();
data.set("item", oldItem);
consumer.queueEntityModification(actor, entity, EntityChange.EntityChangeType.REMOVEEQUIP, data);
consumer.queueEntityModification(actor, entity.getUniqueId(), entity.getType(), entity.getLocation(), EntityChange.EntityChangeType.REMOVEEQUIP, data);
}
}
}
@ -257,18 +225,6 @@ public class AdvancedEntityLogging extends LoggingListener {
lastEntityDamagedForDeathUUID = entity.getUniqueId();
lastEntityDamagedForDeathSerialized = WorldEditHelper.serializeEntity(entity);
}
if (entity instanceof EnderCrystal) {
if (Config.isLogging(entity.getWorld(), EntityLogging.DESTROY, entity)) {
if (event instanceof EntityDamageByEntityEvent) {
Entity damager = LoggingUtil.getRealDamager(((EntityDamageByEntityEvent) event).getDamager());
if (lastEntityDamagedForDeathDamager == null || !(damager instanceof EnderCrystal)) {
lastEntityDamagedForDeathDamager = damager;
}
}
Actor actor = lastEntityDamagedForDeathDamager != null ? Actor.actorFromEntity(lastEntityDamagedForDeathDamager) : new Actor(event.getCause().toString());
queueEntitySpawnOrKill(entity, actor, EntityChange.EntityChangeType.KILL);
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@ -277,7 +233,7 @@ public class AdvancedEntityLogging extends LoggingListener {
if (damager instanceof Bee && !((Bee) damager).hasStung()) {
if (Config.isLogging(damager.getWorld(), EntityLogging.MODIFY, damager)) {
Actor actor = Actor.actorFromEntity(event.getEntity());
consumer.queueEntityModification(actor, damager, EntityChange.EntityChangeType.GET_STUNG, null);
consumer.queueEntityModification(actor, damager.getUniqueId(), damager.getType(), damager.getLocation(), EntityChange.EntityChangeType.GET_STUNG, null);
}
}
}
@ -298,13 +254,13 @@ public class AdvancedEntityLogging extends LoggingListener {
YamlConfiguration data = new YamlConfiguration();
data.set("item", oldItem);
data.set("slot", event.getSlot().name());
consumer.queueEntityModification(actor, entity, EntityChange.EntityChangeType.REMOVEEQUIP, data);
consumer.queueEntityModification(actor, entity.getUniqueId(), entity.getType(), entity.getLocation(), EntityChange.EntityChangeType.REMOVEEQUIP, data);
}
if (!newEmpty) {
YamlConfiguration data = new YamlConfiguration();
data.set("item", newItem);
data.set("slot", event.getSlot().name());
consumer.queueEntityModification(actor, entity, EntityChange.EntityChangeType.ADDEQUIP, data);
consumer.queueEntityModification(actor, entity.getUniqueId(), entity.getType(), entity.getLocation(), EntityChange.EntityChangeType.ADDEQUIP, data);
}
}
}
@ -322,6 +278,6 @@ public class AdvancedEntityLogging extends LoggingListener {
} else {
data.set("worldedit", WorldEditHelper.serializeEntity(entity));
}
consumer.queueEntityModification(actor, entity, changeType, data);
consumer.queueEntityModification(actor, entity.getUniqueId(), entity.getType(), location, changeType, data);
}
}

96
src/main/java/de/diddiz/LogBlock/listeners/BanListener.java
View File

@ -1,48 +1,48 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.CommandsHandler;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.QueryParams;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import static de.diddiz.LogBlock.config.Config.banPermission;
import static de.diddiz.LogBlock.config.Config.isLogged;
import static org.bukkit.Bukkit.getScheduler;
public class BanListener implements Listener {
private final CommandsHandler handler;
private final LogBlock logblock;
public BanListener(LogBlock logblock) {
this.logblock = logblock;
handler = logblock.getCommandsHandler();
}
@EventHandler
public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event) {
final String[] split = event.getMessage().split(" ");
if (split.length > 1 && split[0].equalsIgnoreCase("/ban") && logblock.hasPermission(event.getPlayer(), banPermission)) {
final QueryParams p = new QueryParams(logblock);
p.setPlayer(split[1].equalsIgnoreCase("g") ? split[2] : split[1]);
p.since = 0;
p.silent = false;
getScheduler().runTaskAsynchronously(logblock, new Runnable() {
@Override
public void run() {
for (final World world : logblock.getServer().getWorlds()) {
if (isLogged(world)) {
p.world = world;
try {
handler.new CommandRollback(event.getPlayer(), p, false);
} catch (final Exception ex) {
}
}
}
}
});
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.CommandsHandler;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.QueryParams;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import static de.diddiz.LogBlock.config.Config.banPermission;
import static de.diddiz.LogBlock.config.Config.isLogged;
import static org.bukkit.Bukkit.getScheduler;
public class BanListener implements Listener {
private final CommandsHandler handler;
private final LogBlock logblock;
public BanListener(LogBlock logblock) {
this.logblock = logblock;
handler = logblock.getCommandsHandler();
}
@EventHandler
public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event) {
final String[] split = event.getMessage().split(" ");
if (split.length > 1 && split[0].equalsIgnoreCase("/ban") && logblock.hasPermission(event.getPlayer(), banPermission)) {
final QueryParams p = new QueryParams(logblock);
p.setPlayer(split[1].equalsIgnoreCase("g") ? split[2] : split[1]);
p.since = 0;
p.silent = false;
getScheduler().runTaskAsynchronously(logblock, new Runnable() {
@Override
public void run() {
for (final World world : logblock.getServer().getWorlds()) {
if (isLogged(world)) {
p.world = world;
try {
handler.new CommandRollback(event.getPlayer(), p, false);
} catch (final Exception ex) {
}
}
}
}
});
}
}
}

163
src/main/java/de/diddiz/LogBlock/listeners/BlockBreakLogging.java
View File

@ -1,88 +1,75 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockDropItemEvent;
import org.bukkit.event.player.PlayerBucketFillEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogBlockReplace;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogFallables;
public class BlockBreakLogging extends LoggingListener {
public BlockBreakLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.BLOCKBREAK)) {
WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg == null) {
return;
}
final Actor actor = Actor.actorFromEntity(event.getPlayer());
final Block origin = event.getBlock();
final Material type = origin.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && BukkitUtils.isContainerBlock(type) && !BukkitUtils.isShulkerBoxBlock(type)) {
consumer.queueContainerBreak(actor, origin.getState());
} else if (type == Material.ICE) {
// When in creative mode ice doesn't form water
if (event.getPlayer().getGameMode().equals(GameMode.CREATIVE)) {
smartLogBlockBreak(consumer, actor, origin);
} else {
smartLogBlockReplace(consumer, actor, origin, Bukkit.createBlockData(Material.WATER));
}
} else {
smartLogBlockBreak(consumer, actor, origin);
}
smartLogFallables(consumer, actor, origin);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerBucketFill(PlayerBucketFillEvent event) {
if (isLogging(event.getBlockClicked().getWorld(), Logging.BLOCKBREAK)) {
BlockData clickedBlockData = event.getBlockClicked().getBlockData();
if (clickedBlockData instanceof Waterlogged) {
Waterlogged clickedWaterlogged = (Waterlogged) clickedBlockData;
if (clickedWaterlogged.isWaterlogged()) {
Waterlogged clickedWaterloggedWithoutWater = (Waterlogged) clickedWaterlogged.clone();
clickedWaterloggedWithoutWater.setWaterlogged(false);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getLocation(), clickedWaterlogged, clickedWaterloggedWithoutWater);
}
} else {
consumer.queueBlockBreak(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getState());
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockDropItem(BlockDropItemEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.BLOCKBREAK)) {
Material type = event.getBlock().getType();
if (type == Material.SUSPICIOUS_GRAVEL || type == Material.SUSPICIOUS_SAND) {
Material simplyBroken = type == Material.SUSPICIOUS_SAND ? Material.SAND : Material.GRAVEL;
if (event.getItems().size() != 1 || event.getItems().get(0).getItemStack().getType() != simplyBroken) {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlockState(), simplyBroken.createBlockData());
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerBucketFillEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.util.LoggingUtil.smartLogBlockReplace;
import static de.diddiz.util.LoggingUtil.smartLogFallables;
public class BlockBreakLogging extends LoggingListener {
public BlockBreakLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.BLOCKBREAK)) {
WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg == null) {
return;
}
final Actor actor = Actor.actorFromEntity(event.getPlayer());
final Block origin = event.getBlock();
final Material type = origin.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && BukkitUtils.getContainerBlocks().contains(type) && !BukkitUtils.getShulkerBoxBlocks().contains(type)) {
consumer.queueContainerBreak(actor, origin.getState());
} else if (type == Material.ICE) {
// When in creative mode ice doesn't form water
if (event.getPlayer().getGameMode().equals(GameMode.CREATIVE)) {
smartLogBlockBreak(consumer, actor, origin);
} else {
smartLogBlockReplace(consumer, actor, origin, Bukkit.createBlockData(Material.WATER));
}
} else {
smartLogBlockBreak(consumer, actor, origin);
}
smartLogFallables(consumer, actor, origin);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerBucketFill(PlayerBucketFillEvent event) {
if (isLogging(event.getBlockClicked().getWorld(), Logging.BLOCKBREAK)) {
BlockData clickedBlockData = event.getBlockClicked().getBlockData();
if (clickedBlockData instanceof Waterlogged) {
Waterlogged clickedWaterlogged = (Waterlogged) clickedBlockData;
if (clickedWaterlogged.isWaterlogged()) {
Waterlogged clickedWaterloggedWithoutWater = (Waterlogged) clickedWaterlogged.clone();
clickedWaterloggedWithoutWater.setWaterlogged(false);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getLocation(), clickedWaterlogged, clickedWaterloggedWithoutWater);
}
} else {
consumer.queueBlockBreak(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getState());
}
}
}
}

144
src/main/java/de/diddiz/LogBlock/listeners/BlockBurnLogging.java
View File

@ -1,72 +1,72 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
import org.bukkit.event.player.PlayerInteractEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogBlockReplace;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogFallables;
public class BlockBurnLogging extends LoggingListener {
public BlockBurnLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBurn(BlockBurnEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.FIRE)) {
smartLogBlockReplace(consumer, new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null), event.getBlock(), Material.FIRE.createBlockData());
smartLogFallables(consumer, new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null), event.getBlock());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockIgnite(BlockIgniteEvent event) {
Actor actor = new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null);
if (event.getCause() == IgniteCause.FLINT_AND_STEEL) {
if (event.getIgnitingEntity() != null) {
return; // handled in block place
} else {
actor = new Actor("Dispenser");
}
} else if (event.getCause() == IgniteCause.LIGHTNING) {
actor = new Actor("Lightning");
} else if (event.getCause() == IgniteCause.EXPLOSION) {
actor = new Actor("Explosion");
} else if (event.getCause() == IgniteCause.LAVA) {
actor = new Actor("Lava");
} else if (event.getCause() == IgniteCause.ENDER_CRYSTAL) {
actor = new Actor("EnderCrystal");
}
if (isLogging(event.getBlock().getWorld(), Logging.FIRE)) {
consumer.queueBlockPlace(actor, event.getBlock().getLocation(), Material.FIRE.createBlockData());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onExtinguish(PlayerInteractEvent event) {
if (event.getAction().equals(Action.LEFT_CLICK_BLOCK)) {
Player player = event.getPlayer();
Block block = event.getClickedBlock().getRelative(event.getBlockFace());
if (block.getType().equals(Material.FIRE) && isLogging(player.getWorld(), Logging.FIRE)) {
Actor actor = Actor.actorFromEntity(player);
smartLogBlockBreak(consumer, actor, block);
smartLogFallables(consumer, actor, block);
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
import org.bukkit.event.player.PlayerInteractEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.util.LoggingUtil.smartLogBlockReplace;
import static de.diddiz.util.LoggingUtil.smartLogFallables;
public class BlockBurnLogging extends LoggingListener {
public BlockBurnLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBurn(BlockBurnEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.FIRE)) {
smartLogBlockReplace(consumer, new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null), event.getBlock(), Material.FIRE.createBlockData());
smartLogFallables(consumer, new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null), event.getBlock());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockIgnite(BlockIgniteEvent event) {
Actor actor = new Actor("Fire", Config.logFireSpreadAsPlayerWhoCreatedIt ? event.getIgnitingBlock() : null);
if (event.getCause() == IgniteCause.FLINT_AND_STEEL) {
if (event.getIgnitingEntity() != null) {
return; // handled in block place
} else {
actor = new Actor("Dispenser");
}
} else if (event.getCause() == IgniteCause.LIGHTNING) {
actor = new Actor("Lightning");
} else if (event.getCause() == IgniteCause.EXPLOSION) {
actor = new Actor("Explosion");
} else if (event.getCause() == IgniteCause.LAVA) {
actor = new Actor("Lava");
} else if (event.getCause() == IgniteCause.ENDER_CRYSTAL) {
actor = new Actor("EnderCrystal");
}
if (isLogging(event.getBlock().getWorld(), Logging.FIRE)) {
consumer.queueBlockPlace(actor, event.getBlock().getLocation(), Material.FIRE.createBlockData());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onExtinguish(PlayerInteractEvent event) {
if (event.getAction().equals(Action.LEFT_CLICK_BLOCK)) {
Player player = event.getPlayer();
Block block = event.getClickedBlock().getRelative(event.getBlockFace());
if (block.getType().equals(Material.FIRE) && isLogging(player.getWorld(), Logging.FIRE)) {
Actor actor = Actor.actorFromEntity(player);
smartLogBlockBreak(consumer, actor, block);
smartLogFallables(consumer, actor, block);
}
}
}
}

36
src/main/java/de/diddiz/LogBlock/listeners/BlockFertilizeLogging.java
View File

@ -1,36 +0,0 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import org.bukkit.block.BlockState;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFertilizeEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class BlockFertilizeLogging extends LoggingListener {
public BlockFertilizeLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockFertilize(BlockFertilizeEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getBlock().getLocation().getWorld());
if (wcfg != null) {
if (!wcfg.isLogging(Logging.BONEMEALSTRUCTUREGROW)) {
return;
}
final Actor actor;
if (event.getPlayer() != null) {
actor = Actor.actorFromEntity(event.getPlayer());
} else {
actor = new Actor("Dispenser");
}
for (final BlockState state : event.getBlocks()) {
consumer.queueBlockReplace(actor, state.getBlock().getState(), state);
}
}
}
}

135
src/main/java/de/diddiz/LogBlock/listeners/BlockPlaceLogging.java
View File

@ -1,67 +1,68 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.util.LoggingUtil;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class BlockPlaceLogging extends LoggingListener {
public BlockPlaceLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (Config.isLogging(event.getBlock().getWorld(), Logging.BLOCKPLACE)) {
final BlockState before = event.getBlockReplacedState();
final BlockState after = event.getBlockPlaced().getState();
final Actor actor = Actor.actorFromEntity(event.getPlayer());
if (before.getType() == Material.LECTERN && after.getType() == Material.LECTERN) {
return;
}
LoggingUtil.smartLogBlockPlace(consumer, actor, before, after);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.BLOCKPLACE)) {
Material placedMaterial = event.getBucket() == Material.LAVA_BUCKET ? Material.LAVA : Material.WATER;
BlockData clickedBlockData = event.getBlockClicked().getBlockData();
if (placedMaterial == Material.WATER && clickedBlockData instanceof Waterlogged) {
Waterlogged clickedWaterlogged = (Waterlogged) clickedBlockData;
if (!clickedWaterlogged.isWaterlogged()) {
Waterlogged clickedWaterloggedWithWater = (Waterlogged) clickedWaterlogged.clone();
clickedWaterloggedWithWater.setWaterlogged(true);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getLocation(), clickedWaterlogged, clickedWaterloggedWithWater);
return;
}
}
Block placedAt = event.getBlockClicked().getRelative(event.getBlockFace());
if (placedAt.isEmpty()) {
consumer.queueBlockPlace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedMaterial.createBlockData());
} else {
BlockData placedAtBlock = placedAt.getBlockData();
if (placedAtBlock instanceof Waterlogged && !(((Waterlogged) placedAtBlock).isWaterlogged())) {
Waterlogged clickedWaterloggedWithWater = (Waterlogged) placedAtBlock.clone();
clickedWaterloggedWithWater.setWaterlogged(true);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedAtBlock, clickedWaterloggedWithWater);
} else {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedAtBlock, placedMaterial.createBlockData());
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.util.LoggingUtil;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class BlockPlaceLogging extends LoggingListener {
public BlockPlaceLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (Config.isLogging(event.getBlock().getWorld(), Logging.BLOCKPLACE)) {
final BlockState before = event.getBlockReplacedState();
final BlockState after = event.getBlockPlaced().getState();
final Actor actor = Actor.actorFromEntity(event.getPlayer());
if (before.getType() == Material.LECTERN && after.getType() == Material.LECTERN) {
return;
}
LoggingUtil.smartLogBlockPlace(consumer, actor, before, after);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.BLOCKPLACE)) {
Material placedMaterial = event.getBucket() == Material.LAVA_BUCKET ? Material.LAVA : Material.WATER;
BlockData clickedBlockData = event.getBlockClicked().getBlockData();
if (placedMaterial == Material.WATER && clickedBlockData instanceof Waterlogged) {
Waterlogged clickedWaterlogged = (Waterlogged) clickedBlockData;
if (!clickedWaterlogged.isWaterlogged()) {
Waterlogged clickedWaterloggedWithWater = (Waterlogged) clickedWaterlogged.clone();
clickedWaterloggedWithWater.setWaterlogged(true);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlockClicked().getLocation(), clickedWaterlogged, clickedWaterloggedWithWater);
return;
}
}
Block placedAt = event.getBlockClicked().getRelative(event.getBlockFace());
if (placedAt.isEmpty()) {
consumer.queueBlockPlace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedMaterial.createBlockData());
} else {
BlockData placedAtBlock = placedAt.getBlockData();
if (placedAtBlock instanceof Waterlogged && !(((Waterlogged) placedAtBlock).isWaterlogged())) {
Waterlogged clickedWaterloggedWithWater = (Waterlogged) placedAtBlock.clone();
clickedWaterloggedWithWater.setWaterlogged(true);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedAtBlock, clickedWaterloggedWithWater);
} else {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), placedAt.getLocation(), placedAtBlock, placedMaterial.createBlockData());
}
}
}
}
}

107
src/main/java/de/diddiz/LogBlock/listeners/BlockSpreadLogging.java
View File

@ -5,10 +5,6 @@ import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.type.PointedDripstone;
import org.bukkit.block.data.type.PointedDripstone.Thickness;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockSpreadEvent;
@ -26,74 +22,49 @@ public class BlockSpreadLogging extends LoggingListener {
String name;
World world = event.getNewState().getWorld();
Material type = event.getNewState().getType();
World world = event.getBlock().getWorld();
Material type = event.getSource().getType();
if (type == Material.SHORT_GRASS) {
if (!isLogging(world, Logging.GRASSGROWTH)) {
return;
}
name = "GrassGrowth";
} else if (type == Material.MYCELIUM) {
if (!isLogging(world, Logging.MYCELIUMSPREAD)) {
return;
}
name = "MyceliumSpread";
} else if (type == Material.VINE || type == Material.CAVE_VINES || type == Material.CAVE_VINES_PLANT || type == Material.WEEPING_VINES || type == Material.WEEPING_VINES_PLANT || type == Material.TWISTING_VINES || type == Material.TWISTING_VINES_PLANT) {
if (!isLogging(world, Logging.VINEGROWTH)) {
return;
}
name = "VineGrowth";
} else if (type == Material.RED_MUSHROOM || type == Material.BROWN_MUSHROOM) {
if (!isLogging(world, Logging.MUSHROOMSPREAD)) {
return;
}
name = "MushroomSpread";
} else if (type == Material.BAMBOO || type == Material.BAMBOO_SAPLING) {
if (!isLogging(world, Logging.BAMBOOGROWTH)) {
return;
}
name = "BambooGrowth";
if (type == Material.BAMBOO_SAPLING) {
// bamboo sapling gets replaced by bamboo
consumer.queueBlockReplace(new Actor(name), event.getSource().getState(), Material.BAMBOO.createBlockData());
}
} else if (type == Material.POINTED_DRIPSTONE) {
if (!isLogging(world, Logging.DRIPSTONEGROWTH)) {
return;
}
name = "DripstoneGrowth";
PointedDripstone pointed = (PointedDripstone) event.getNewState().getBlockData();
if (pointed.getThickness() != Thickness.TIP_MERGE) {
BlockFace direction = pointed.getVerticalDirection();
Block previousPart = event.getBlock().getRelative(direction.getOppositeFace());
if (previousPart.getType() == Material.POINTED_DRIPSTONE) {
PointedDripstone newBelow = (PointedDripstone) previousPart.getBlockData();
newBelow.setThickness(Thickness.FRUSTUM);
consumer.queueBlockReplace(new Actor(name), previousPart.getState(), newBelow);
previousPart = previousPart.getRelative(direction.getOppositeFace());
if (previousPart.getType() == Material.POINTED_DRIPSTONE) {
Block evenMorePrevious = previousPart.getRelative(direction.getOppositeFace());
newBelow = (PointedDripstone) previousPart.getBlockData();
newBelow.setThickness(evenMorePrevious.getType() == Material.POINTED_DRIPSTONE ? Thickness.MIDDLE : Thickness.BASE);
consumer.queueBlockReplace(new Actor(name), previousPart.getState(), newBelow);
}
switch (type) {
case GRASS:
if (!isLogging(world, Logging.GRASSGROWTH)) {
return;
}
} else {
// special case because the old state is already changed (for one half)
PointedDripstone oldState = (PointedDripstone) event.getNewState().getBlockData();
oldState.setThickness(Thickness.TIP);
consumer.queueBlockReplace(new Actor(name), oldState, event.getNewState());
return;
name = "GrassGrowth";
break;
case MYCELIUM:
if (!isLogging(world, Logging.MYCELIUMSPREAD)) {
return;
}
name = "MyceliumSpread";
break;
case VINE:
if (!isLogging(world, Logging.VINEGROWTH)) {
return;
}
name = "VineGrowth";
break;
case RED_MUSHROOM:
case BROWN_MUSHROOM:
if (!isLogging(world, Logging.MUSHROOMSPREAD)) {
return;
}
name = "MushroomSpread";
break;
case BAMBOO:
case BAMBOO_SAPLING: {
if (!isLogging(world, Logging.BAMBOOGROWTH)) {
return;
}
name = "BambooGrowth";
if (type == Material.BAMBOO_SAPLING) {
// bamboo sapling gets replaced by bamboo
consumer.queueBlockReplace(new Actor(name), event.getSource().getState(), Material.BAMBOO.createBlockData());
}
break;
}
} else if (type == Material.SCULK || type == Material.SCULK_VEIN || type == Material.SCULK_CATALYST || type == Material.SCULK_SENSOR || type == Material.SCULK_SHRIEKER) {
if (!isLogging(world, Logging.SCULKSPREAD)) {
default:
return;
}
name = "SculkSpread";
} else {
return;
}
consumer.queueBlockReplace(new Actor(name), event.getBlock().getState(), event.getNewState());

27
src/main/java/de/diddiz/LogBlock/listeners/CauldronLogging.java
View File

@ -1,27 +0,0 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.CauldronLevelChangeEvent;
public class CauldronLogging extends LoggingListener {
public CauldronLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onCauldronLevelChange(CauldronLevelChangeEvent event) {
if (Config.isLogging(event.getBlock().getWorld(), Logging.CAULDRONINTERACT)) {
Entity causingEntity = event.getEntity();
if (causingEntity instanceof Player) {
consumer.queueBlockReplace(Actor.actorFromEntity(causingEntity), event.getBlock().getBlockData(), event.getNewState());
}
}
}
}

116
src/main/java/de/diddiz/LogBlock/listeners/ChatLogging.java
View File

@ -1,58 +1,58 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.minecart.CommandMinecart;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.server.ServerCommandEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class ChatLogging extends LoggingListener {
public ChatLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.PLAYER_COMMANDS)) {
consumer.queueChat(Actor.actorFromEntity(event.getPlayer()), event.getMessage());
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerChat(AsyncPlayerChatEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.CHAT)) {
consumer.queueChat(Actor.actorFromEntity(event.getPlayer()), event.getMessage());
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void onServerCommand(ServerCommandEvent event) {
CommandSender sender = event.getSender();
Actor actor;
if (sender instanceof BlockCommandSender) {
if (!isLogging(((BlockCommandSender) sender).getBlock().getWorld(), Logging.COMMANDBLOCK_COMMANDS)) {
return;
}
actor = new Actor("CommandBlock");
} else if (sender instanceof CommandMinecart) {
if (!isLogging(((CommandMinecart) sender).getWorld(), Logging.COMMANDBLOCK_COMMANDS)) {
return;
}
actor = new Actor("CommandMinecart");
} else {
if (!isLogging(Logging.CONSOLE_COMMANDS)) {
return;
}
actor = new Actor("Console");
}
consumer.queueChat(actor, "/" + event.getCommand());
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.minecart.CommandMinecart;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.server.ServerCommandEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class ChatLogging extends LoggingListener {
public ChatLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.PLAYER_COMMANDS)) {
consumer.queueChat(Actor.actorFromEntity(event.getPlayer()), event.getMessage());
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerChat(AsyncPlayerChatEvent event) {
if (isLogging(event.getPlayer().getWorld(), Logging.CHAT)) {
consumer.queueChat(Actor.actorFromEntity(event.getPlayer()), event.getMessage());
}
}
@EventHandler(priority = EventPriority.MONITOR)
public void onServerCommand(ServerCommandEvent event) {
CommandSender sender = event.getSender();
Actor actor;
if (sender instanceof BlockCommandSender) {
if (!isLogging(((BlockCommandSender) sender).getBlock().getWorld(), Logging.COMMANDBLOCK_COMMANDS)) {
return;
}
actor = new Actor("CommandBlock");
} else if (sender instanceof CommandMinecart) {
if (!isLogging(((CommandMinecart) sender).getWorld(), Logging.COMMANDBLOCK_COMMANDS)) {
return;
}
actor = new Actor("CommandMinecart");
} else {
if (!isLogging(Logging.CONSOLE_COMMANDS)) {
return;
}
actor = new Actor("Console");
}
consumer.queueChat(actor, "/" + event.getCommand());
}
}

606
src/main/java/de/diddiz/LogBlock/listeners/ChestAccessLogging.java
View File

@ -1,303 +1,303 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.DoubleChest;
import org.bukkit.entity.HumanEntity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.LogBlock.util.BukkitUtils.*;
public class ChestAccessLogging extends LoggingListener {
private class PlayerActiveInventoryModifications {
private final HumanEntity actor;
private final Location location;
private final HashMap<ItemStack, Integer> modifications;
public PlayerActiveInventoryModifications(HumanEntity actor, Location location) {
this.actor = actor;
this.location = location;
this.modifications = new HashMap<>();
}
public void addModification(ItemStack stack, int amount) {
if (amount == 0) {
return;
}
// if we have other viewers, we have to flush their changes
ArrayList<PlayerActiveInventoryModifications> allViewers = containersByLocation.get(location);
if (allViewers.size() > 1) {
for (PlayerActiveInventoryModifications other : allViewers) {
if (other != this) {
other.flush();
}
}
}
// consumer.getLogblock().getLogger().info("Modify container: " + stack + " change: " + amount);
stack = new ItemStack(stack);
stack.setAmount(1);
Integer existing = modifications.get(stack);
int newTotal = amount + (existing == null ? 0 : existing);
if (newTotal == 0) {
modifications.remove(stack);
} else {
modifications.put(stack, newTotal);
}
}
public void flush() {
if (!modifications.isEmpty()) {
for (Entry<ItemStack, Integer> e : modifications.entrySet()) {
ItemStack stack = e.getKey();
int amount = e.getValue();
stack.setAmount(Math.abs(amount));
// consumer.getLogblock().getLogger().info("Store container: " + stack + " take: " + (amount < 0));
consumer.queueChestAccess(Actor.actorFromEntity(actor), location, location.getWorld().getBlockAt(location).getBlockData(), stack, amount < 0);
}
modifications.clear();
}
}
public HumanEntity getActor() {
return actor;
}
public Location getLocation() {
return location;
}
}
private final Map<HumanEntity, PlayerActiveInventoryModifications> containersByOwner = new HashMap<>();
private final Map<Location, ArrayList<PlayerActiveInventoryModifications>> containersByLocation = new HashMap<>();
public ChestAccessLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryClose(InventoryCloseEvent event) {
final HumanEntity player = event.getPlayer();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.remove(player);
if (modifications != null) {
final Location loc = modifications.getLocation();
ArrayList<PlayerActiveInventoryModifications> atLocation = containersByLocation.get(loc);
atLocation.remove(modifications);
if (atLocation.isEmpty()) {
containersByLocation.remove(loc);
}
modifications.flush();
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryOpen(InventoryOpenEvent event) {
final HumanEntity player = event.getPlayer();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
if (event.getInventory() != null) {
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
if (getInventoryHolderType(holder) != Material.CRAFTING_TABLE) {
PlayerActiveInventoryModifications modifications = new PlayerActiveInventoryModifications(event.getPlayer(), getInventoryHolderLocation(holder));
containersByOwner.put(modifications.getActor(), modifications);
containersByLocation.compute(modifications.getLocation(), (k, v) -> {
if (v == null) {
v = new ArrayList<>();
}
v.add(modifications);
return v;
});
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryClick(InventoryClickEvent event) {
final HumanEntity player = event.getWhoClicked();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.get(player);
if (modifications != null) {
switch (event.getAction()) {
case PICKUP_ONE:
case DROP_ONE_SLOT:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -1);
}
break;
case PICKUP_HALF:
// server behaviour: round up
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -(event.getCurrentItem().getAmount() + 1) / 2);
}
break;
case PICKUP_SOME: // oversized stack - can not take all when clicking
// server behaviour: leave a full stack in the slot, take everything else
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
int taken = event.getCurrentItem().getAmount() - event.getCurrentItem().getMaxStackSize();
modifications.addModification(event.getCursor(), -taken);
}
break;
case PICKUP_ALL:
case DROP_ALL_SLOT:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
break;
case PLACE_ONE:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), 1);
}
break;
case PLACE_SOME: // not enough free place in target slot
// server behaviour: place as much as possible
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
int placeable = event.getCurrentItem().getMaxStackSize() - event.getCurrentItem().getAmount();
modifications.addModification(event.getCursor(), placeable);
}
break;
case PLACE_ALL:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), event.getCursor().getAmount());
}
break;
case SWAP_WITH_CURSOR:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), event.getCursor().getAmount());
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
break;
case MOVE_TO_OTHER_INVENTORY: // shift + click
boolean removed = event.getRawSlot() < event.getView().getTopInventory().getSize();
modifications.addModification(event.getCurrentItem(), event.getCurrentItem().getAmount() * (removed ? -1 : 1));
break;
case COLLECT_TO_CURSOR: // double click
// server behaviour: first collect all with an amount != maxstacksize, then others, starting from slot 0 (container)
ItemStack cursor = event.getCursor();
if (cursor == null) {
return;
}
int toPickUp = cursor.getMaxStackSize() - cursor.getAmount();
int takenFromContainer = 0;
boolean takeFromFullStacks = false;
Inventory top = event.getView().getTopInventory();
Inventory bottom = event.getView().getBottomInventory();
while (toPickUp > 0) {
for (ItemStack stack : top.getStorageContents()) {
if (cursor.isSimilar(stack)) {
if (takeFromFullStacks == (stack.getAmount() == stack.getMaxStackSize())) {
int take = Math.min(toPickUp, stack.getAmount());
toPickUp -= take;
takenFromContainer += take;
if (toPickUp <= 0) {
break;
}
}
}
}
if (toPickUp <= 0) {
break;
}
for (ItemStack stack : bottom.getStorageContents()) {
if (cursor.isSimilar(stack)) {
if (takeFromFullStacks == (stack.getAmount() == stack.getMaxStackSize())) {
int take = Math.min(toPickUp, stack.getAmount());
toPickUp -= take;
if (toPickUp <= 0) {
break;
}
}
}
}
if (takeFromFullStacks) {
break;
} else {
takeFromFullStacks = true;
}
}
if (takenFromContainer > 0) {
modifications.addModification(event.getCursor(), -takenFromContainer);
}
break;
case HOTBAR_SWAP: // number key or offhand key
case HOTBAR_MOVE_AND_READD: // something was in the other slot
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
ItemStack otherSlot = (event.getClick() == ClickType.SWAP_OFFHAND) ? event.getWhoClicked().getInventory().getItemInOffHand() : event.getWhoClicked().getInventory().getItem(event.getHotbarButton());
if (event.getCurrentItem() != null && event.getCurrentItem().getType() != Material.AIR) {
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
if (otherSlot != null && otherSlot.getType() != Material.AIR) {
modifications.addModification(otherSlot, otherSlot.getAmount());
}
}
break;
case DROP_ALL_CURSOR:
case DROP_ONE_CURSOR:
case CLONE_STACK:
case NOTHING:
// only the cursor or nothing (but not the inventory) was modified
break;
case UNKNOWN:
default:
// unable to log something we don't know
consumer.getLogblock().getLogger().warning("Unknown inventory action by " + event.getWhoClicked().getName() + ": " + event.getAction() + " Slot: " + event.getSlot() + " Slot type: " + event.getSlotType());
break;
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryDrag(InventoryDragEvent event) {
final HumanEntity player = event.getWhoClicked();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.get(player);
if (modifications != null) {
Inventory container = event.getView().getTopInventory();
int containerSize = container.getSize();
for (Entry<Integer, ItemStack> e : event.getNewItems().entrySet()) {
int slot = e.getKey();
if (slot < containerSize) {
ItemStack old = container.getItem(slot);
int oldAmount = (old == null || old.getType() == Material.AIR) ? 0 : old.getAmount();
modifications.addModification(e.getValue(), e.getValue().getAmount() - oldAmount);
}
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.block.DoubleChest;
import org.bukkit.entity.HumanEntity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.util.BukkitUtils.*;
public class ChestAccessLogging extends LoggingListener {
private class PlayerActiveInventoryModifications {
private final HumanEntity actor;
private final Location location;
private final HashMap<ItemStack, Integer> modifications;
public PlayerActiveInventoryModifications(HumanEntity actor, Location location) {
this.actor = actor;
this.location = location;
this.modifications = new HashMap<>();
}
public void addModification(ItemStack stack, int amount) {
if (amount == 0) {
return;
}
// if we have other viewers, we have to flush their changes
ArrayList<PlayerActiveInventoryModifications> allViewers = containersByLocation.get(location);
if (allViewers.size() > 1) {
for (PlayerActiveInventoryModifications other : allViewers) {
if (other != this) {
other.flush();
}
}
}
consumer.getLogblock().getLogger().info("Modify container: " + stack + " change: " + amount);
stack = new ItemStack(stack);
stack.setAmount(1);
Integer existing = modifications.get(stack);
int newTotal = amount + (existing == null ? 0 : existing);
if (newTotal == 0) {
modifications.remove(stack);
} else {
modifications.put(stack, newTotal);
}
}
public void flush() {
if (!modifications.isEmpty()) {
for (Entry<ItemStack, Integer> e : modifications.entrySet()) {
ItemStack stack = e.getKey();
int amount = e.getValue();
stack.setAmount(Math.abs(amount));
consumer.getLogblock().getLogger().info("Store container: " + stack + " take: " + (amount < 0));
consumer.queueChestAccess(Actor.actorFromEntity(actor), location, location.getWorld().getBlockAt(location).getBlockData(), stack, amount < 0);
}
modifications.clear();
}
}
public HumanEntity getActor() {
return actor;
}
public Location getLocation() {
return location;
}
}
private final Map<HumanEntity, PlayerActiveInventoryModifications> containersByOwner = new HashMap<>();
private final Map<Location, ArrayList<PlayerActiveInventoryModifications>> containersByLocation = new HashMap<>();
public ChestAccessLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryClose(InventoryCloseEvent event) {
final HumanEntity player = event.getPlayer();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.remove(player);
if (modifications != null) {
final Location loc = modifications.getLocation();
ArrayList<PlayerActiveInventoryModifications> atLocation = containersByLocation.get(loc);
atLocation.remove(modifications);
if (atLocation.isEmpty()) {
containersByLocation.remove(loc);
}
modifications.flush();
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryOpen(InventoryOpenEvent event) {
final HumanEntity player = event.getPlayer();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
if (event.getInventory() != null) {
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
if (getInventoryHolderType(holder) != Material.CRAFTING_TABLE) {
PlayerActiveInventoryModifications modifications = new PlayerActiveInventoryModifications(event.getPlayer(), getInventoryHolderLocation(holder));
containersByOwner.put(modifications.getActor(), modifications);
containersByLocation.compute(modifications.getLocation(), (k, v) -> {
if (v == null) {
v = new ArrayList<>();
}
v.add(modifications);
return v;
});
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryClick(InventoryClickEvent event) {
final HumanEntity player = event.getWhoClicked();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.get(player);
if (modifications != null) {
switch (event.getAction()) {
case PICKUP_ONE:
case DROP_ONE_SLOT:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -1);
}
break;
case PICKUP_HALF:
// server behaviour: round up
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -(event.getCurrentItem().getAmount() + 1) / 2);
}
break;
case PICKUP_SOME: // oversized stack - can not take all when clicking
// server behaviour: leave a full stack in the slot, take everything else
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
int taken = event.getCurrentItem().getAmount() - event.getCurrentItem().getMaxStackSize();
modifications.addModification(event.getCursor(), -taken);
}
break;
case PICKUP_ALL:
case DROP_ALL_SLOT:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
break;
case PLACE_ONE:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), 1);
}
break;
case PLACE_SOME: // not enough free place in target slot
// server behaviour: place as much as possible
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
int placeable = event.getCurrentItem().getMaxStackSize() - event.getCurrentItem().getAmount();
modifications.addModification(event.getCursor(), placeable);
}
break;
case PLACE_ALL:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), event.getCursor().getAmount());
}
break;
case SWAP_WITH_CURSOR:
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
modifications.addModification(event.getCursor(), event.getCursor().getAmount());
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
break;
case MOVE_TO_OTHER_INVENTORY: // shift + click
boolean removed = event.getRawSlot() < event.getView().getTopInventory().getSize();
modifications.addModification(event.getCurrentItem(), event.getCurrentItem().getAmount() * (removed ? -1 : 1));
break;
case COLLECT_TO_CURSOR: // double click
// server behaviour: first collect all with an amount != maxstacksize, then others, starting from slot 0 (container)
ItemStack cursor = event.getCursor();
if (cursor == null) {
return;
}
int toPickUp = cursor.getMaxStackSize() - cursor.getAmount();
int takenFromContainer = 0;
boolean takeFromFullStacks = false;
Inventory top = event.getView().getTopInventory();
Inventory bottom = event.getView().getBottomInventory();
while (toPickUp > 0) {
for (ItemStack stack : top.getStorageContents()) {
if (cursor.isSimilar(stack)) {
if (takeFromFullStacks == (stack.getAmount() == stack.getMaxStackSize())) {
int take = Math.min(toPickUp, stack.getAmount());
toPickUp -= take;
takenFromContainer += take;
if (toPickUp <= 0) {
break;
}
}
}
}
if (toPickUp <= 0) {
break;
}
for (ItemStack stack : bottom.getStorageContents()) {
if (cursor.isSimilar(stack)) {
if (takeFromFullStacks == (stack.getAmount() == stack.getMaxStackSize())) {
int take = Math.min(toPickUp, stack.getAmount());
toPickUp -= take;
if (toPickUp <= 0) {
break;
}
}
}
}
if (takeFromFullStacks) {
break;
} else {
takeFromFullStacks = true;
}
}
if (takenFromContainer > 0) {
modifications.addModification(event.getCursor(), -takenFromContainer);
}
break;
case HOTBAR_SWAP: // number key or offhand key
case HOTBAR_MOVE_AND_READD: // something was in the other slot
if (event.getRawSlot() < event.getView().getTopInventory().getSize()) {
ItemStack otherSlot = (event.getClick() == ClickType.SWAP_OFFHAND) ? event.getWhoClicked().getInventory().getItemInOffHand() : event.getWhoClicked().getInventory().getItem(event.getHotbarButton());
if (event.getCurrentItem() != null && event.getCurrentItem().getType() != Material.AIR) {
modifications.addModification(event.getCurrentItem(), -event.getCurrentItem().getAmount());
}
if (otherSlot != null && otherSlot.getType() != Material.AIR) {
modifications.addModification(otherSlot, otherSlot.getAmount());
}
}
break;
case DROP_ALL_CURSOR:
case DROP_ONE_CURSOR:
case CLONE_STACK:
case NOTHING:
// only the cursor or nothing (but not the inventory) was modified
break;
case UNKNOWN:
default:
// unable to log something we don't know
consumer.getLogblock().getLogger().warning("Unknown inventory action by " + event.getWhoClicked().getName() + ": " + event.getAction() + " Slot: " + event.getSlot() + " Slot type: " + event.getSlotType());
break;
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryDrag(InventoryDragEvent event) {
final HumanEntity player = event.getWhoClicked();
if (!isLogging(player.getWorld(), Logging.CHESTACCESS)) {
return;
}
InventoryHolder holder = event.getInventory().getHolder();
if (holder instanceof BlockState || holder instanceof DoubleChest) {
final PlayerActiveInventoryModifications modifications = containersByOwner.get(player);
if (modifications != null) {
Inventory container = event.getView().getTopInventory();
int containerSize = container.getSize();
for (Entry<Integer, ItemStack> e : event.getNewItems().entrySet()) {
int slot = e.getKey();
if (slot < containerSize) {
ItemStack old = container.getItem(slot);
int oldAmount = (old == null || old.getType() == Material.AIR) ? 0 : old.getAmount();
modifications.addModification(e.getValue(), e.getValue().getAmount() - oldAmount);
}
}
}
}
}
}

11
src/main/java/de/diddiz/LogBlock/listeners/CreatureInteractLogging.java
View File

@ -4,12 +4,13 @@ import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.type.TurtleEgg;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
@ -26,8 +27,10 @@ public class CreatureInteractLogging extends LoggingListener {
public void onEntityInteract(EntityInteractEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getEntity().getWorld());
final EntityType entityType = event.getEntityType();
// Mobs only
if (event.getEntity() instanceof Player) {
if (event.getEntity() instanceof Player || entityType == null) {
return;
}
@ -39,10 +42,10 @@ public class CreatureInteractLogging extends LoggingListener {
if (type == Material.FARMLAND) {
if (wcfg.isLogging(Logging.CREATURECROPTRAMPLE)) {
// 3 = Dirt ID
consumer.queueBlock(new Actor("CreatureTrample"), loc, type.createBlockData(), Material.DIRT.createBlockData());
consumer.queueBlock(Actor.actorFromEntity(entityType), loc, type.createBlockData(), Material.DIRT.createBlockData());
// Log the crop on top as being broken
Block trampledCrop = clicked.getRelative(BlockFace.UP);
if (BukkitUtils.isCropBlock(trampledCrop.getType())) {
if (BukkitUtils.getCropBlocks().contains(trampledCrop.getType())) {
consumer.queueBlockBreak(new Actor("CreatureTrample"), trampledCrop.getState());
}
}

2
src/main/java/de/diddiz/LogBlock/listeners/DragonEggLogging.java
View File

@ -20,7 +20,7 @@ import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.util.LoggingUtil;
import de.diddiz.util.LoggingUtil;
public class DragonEggLogging extends LoggingListener {

48
src/main/java/de/diddiz/LogBlock/listeners/EndermenLogging.java
View File

@ -1,24 +1,24 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.entity.Enderman;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class EndermenLogging extends LoggingListener {
public EndermenLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityChangeBlock(EntityChangeBlockEvent event) {
if (event.getEntity() instanceof Enderman && isLogging(event.getBlock().getWorld(), Logging.ENDERMEN)) {
consumer.queueBlockReplace(new Actor("Enderman"), event.getBlock().getState(), event.getBlockData()); // Figure out how to get the data of the placed block;
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.entity.Enderman;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class EndermenLogging extends LoggingListener {
public EndermenLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityChangeBlock(EntityChangeBlockEvent event) {
if (event.getEntity() instanceof Enderman && isLogging(event.getBlock().getWorld(), Logging.ENDERMEN)) {
consumer.queueBlockReplace(new Actor("Enderman"), event.getBlock().getState(), event.getBlockData()); // Figure out how to get the data of the placed block;
}
}
}

407
src/main/java/de/diddiz/LogBlock/listeners/ExplosionLogging.java
View File

@ -1,228 +1,179 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.type.RespawnAnchor;
import org.bukkit.entity.*;
import org.bukkit.entity.minecart.ExplosiveMinecart;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockExplodeEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.projectiles.ProjectileSource;
import org.bukkit.scheduler.BukkitRunnable;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
import static de.diddiz.LogBlock.config.Config.logCreeperExplosionsAsPlayerWhoTriggeredThese;
import java.util.UUID;
public class ExplosionLogging extends LoggingListener {
private UUID lastBedInteractionPlayer;
private Location lastBedInteractionLocation;
private UUID lastRespawnAnchorInteractionPlayer;
private Location lastRespawnAnchorInteractionLocation;
public ExplosionLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityExplode(EntityExplodeEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getLocation().getWorld());
if (wcfg != null) {
Actor actor = new Actor("Explosion");
Entity source = event.getEntity();
if (source == null) {
if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
} else if (source instanceof TNTPrimed) {
if (!wcfg.isLogging(Logging.TNTEXPLOSION)) {
return;
}
actor = new Actor("TNT");
} else if (source instanceof ExplosiveMinecart) {
if (!wcfg.isLogging(Logging.TNTMINECARTEXPLOSION)) {
return;
}
actor = new Actor("TNTMinecart");
} else if (source instanceof Creeper) {
if (!wcfg.isLogging(Logging.CREEPEREXPLOSION)) {
return;
}
if (logCreeperExplosionsAsPlayerWhoTriggeredThese) {
final Entity target = ((Creeper) source).getTarget();
actor = target instanceof Player ? Actor.actorFromEntity(target) : new Actor("Creeper");
} else {
actor = new Actor("Creeper");
}
} else if (source instanceof Wither) {
if (!wcfg.isLogging(Logging.WITHER)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof WitherSkull) {
if (!wcfg.isLogging(Logging.WITHER_SKULL)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof Fireball) {
Fireball fireball = (Fireball) source;
ProjectileSource shooter = fireball.getShooter();
if (shooter == null) {
if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (shooter instanceof Ghast) {
if (!wcfg.isLogging(Logging.GHASTFIREBALLEXPLOSION)) {
return;
}
actor = Actor.actorFromProjectileSource(shooter);
} else if (shooter instanceof Wither) {
if (!wcfg.isLogging(Logging.WITHER)) {
return;
}
actor = Actor.actorFromProjectileSource(shooter);
}
} else if (source instanceof EnderDragon) {
if (!wcfg.isLogging(Logging.ENDERDRAGON)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof EnderCrystal) {
if (!wcfg.isLogging(Logging.ENDERCRYSTALEXPLOSION)) {
return;
}
actor = Actor.actorFromEntity(source);
} else {
if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
}
for (final Block block : event.blockList()) {
final Material type = block.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && BukkitUtils.isContainerBlock(type) && !BukkitUtils.isShulkerBoxBlock(type)) {
consumer.queueContainerBreak(actor, block.getState());
} else {
consumer.queueBlockBreak(actor, block.getState());
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.hasBlock()) {
Block block = event.getClickedBlock();
if (BukkitUtils.isBed(block.getType()) && !block.getWorld().isBedWorks()) {
if (!Config.isLogging(block.getWorld(), Logging.BEDEXPLOSION)) {
return;
}
lastBedInteractionPlayer = event.getPlayer().getUniqueId();
lastBedInteractionLocation = block.getLocation();
new BukkitRunnable() {
@Override
public void run() {
lastBedInteractionPlayer = null;
lastBedInteractionLocation = null;
}
}.runTask(LogBlock.getInstance());
} else if (block.getType() == Material.RESPAWN_ANCHOR && block.getBlockData() instanceof RespawnAnchor data) {
if (!Config.isLogging(block.getWorld(), Logging.RESPAWNANCHOREXPLOSION)) {
return;
}
ItemStack inHand = event.getItem();
int charges = data.getCharges();
if (charges < data.getMaximumCharges() && inHand != null && inHand.getType() == Material.GLOWSTONE) {
// charge
Actor actor = Actor.actorFromEntity(event.getPlayer());
RespawnAnchor blockNew = (RespawnAnchor) data.clone();
blockNew.setCharges(charges + 1);
consumer.queueBlockReplace(actor, block.getState(), blockNew);
} else if (charges > 0 && !block.getWorld().isRespawnAnchorWorks()) {
// explode
Actor actor = Actor.actorFromEntity(event.getPlayer());
consumer.queueBlockBreak(actor, block.getState());
lastRespawnAnchorInteractionPlayer = event.getPlayer().getUniqueId();
lastRespawnAnchorInteractionLocation = block.getLocation();
new BukkitRunnable() {
@Override
public void run() {
lastRespawnAnchorInteractionPlayer = null;
lastRespawnAnchorInteractionLocation = null;
}
}.runTask(LogBlock.getInstance());
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockExplode(BlockExplodeEvent event) {
Player bedCause = null;
if (lastBedInteractionPlayer != null && lastBedInteractionLocation != null) {
Location block = event.getBlock().getLocation();
if (lastBedInteractionLocation.getWorld() == block.getWorld() && block.distanceSquared(lastBedInteractionLocation) <= 1) {
bedCause = Bukkit.getPlayer(lastBedInteractionPlayer);
}
}
Player respawnAnchorCause = null;
if (lastRespawnAnchorInteractionPlayer != null && lastRespawnAnchorInteractionLocation != null) {
Location block = event.getBlock().getLocation();
if (lastRespawnAnchorInteractionLocation.equals(block)) {
respawnAnchorCause = Bukkit.getPlayer(lastRespawnAnchorInteractionPlayer);
}
}
for (final Block block : event.blockList()) {
final WorldConfig wcfg = getWorldConfig(block.getLocation().getWorld());
if (wcfg != null) {
Actor actor = new Actor("Explosion");
if (bedCause != null) {
if (!wcfg.isLogging(Logging.BEDEXPLOSION)) {
return;
}
if (Config.logBedExplosionsAsPlayerWhoTriggeredThese) {
actor = Actor.actorFromEntity(bedCause);
} else {
actor = new Actor("BedExplosion");
}
} else if (respawnAnchorCause != null) {
if (!wcfg.isLogging(Logging.RESPAWNANCHOREXPLOSION)) {
return;
}
if (Config.logBedExplosionsAsPlayerWhoTriggeredThese) {
actor = Actor.actorFromEntity(respawnAnchorCause);
} else {
actor = new Actor("RespawnAnchorExplosion");
}
} else if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
final Material type = block.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && BukkitUtils.isContainerBlock(type) && !BukkitUtils.isShulkerBoxBlock(type)) {
consumer.queueContainerBreak(actor, block.getState());
} else {
consumer.queueBlockBreak(actor, block.getState());
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.*;
import org.bukkit.entity.minecart.ExplosiveMinecart;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockExplodeEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.projectiles.ProjectileSource;
import org.bukkit.scheduler.BukkitRunnable;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
import static de.diddiz.LogBlock.config.Config.logCreeperExplosionsAsPlayerWhoTriggeredThese;
import static de.diddiz.util.BukkitUtils.getContainerBlocks;
import java.util.UUID;
public class ExplosionLogging extends LoggingListener {
private UUID lastBedInteractionPlayer;
private Location lastBedInteractionLocation;
public ExplosionLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityExplode(EntityExplodeEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getLocation().getWorld());
if (wcfg != null) {
Actor actor = new Actor("Explosion");
Entity source = event.getEntity();
if (source == null) {
if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
} else if (source instanceof TNTPrimed) {
if (!wcfg.isLogging(Logging.TNTEXPLOSION)) {
return;
}
actor = new Actor("TNT");
} else if (source instanceof ExplosiveMinecart) {
if (!wcfg.isLogging(Logging.TNTMINECARTEXPLOSION)) {
return;
}
actor = new Actor("TNTMinecart");
} else if (source instanceof Creeper) {
if (!wcfg.isLogging(Logging.CREEPEREXPLOSION)) {
return;
}
if (logCreeperExplosionsAsPlayerWhoTriggeredThese) {
final Entity target = ((Creeper) source).getTarget();
actor = target instanceof Player ? Actor.actorFromEntity(target) : new Actor("Creeper");
} else {
new Actor("Creeper");
}
} else if (source instanceof Fireball) {
Fireball fireball = (Fireball) source;
ProjectileSource shooter = fireball.getShooter();
if (shooter == null) {
return;
}
if (shooter instanceof Ghast) {
if (!wcfg.isLogging(Logging.GHASTFIREBALLEXPLOSION)) {
return;
}
actor = Actor.actorFromProjectileSource(shooter);
} else if (shooter instanceof Wither) {
if (!wcfg.isLogging(Logging.WITHER)) {
return;
}
actor = Actor.actorFromProjectileSource(shooter);
}
} else if (source instanceof EnderDragon) {
if (!wcfg.isLogging(Logging.ENDERDRAGON)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof Wither) {
if (!wcfg.isLogging(Logging.WITHER)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof WitherSkull) {
if (!wcfg.isLogging(Logging.WITHER_SKULL)) {
return;
}
actor = Actor.actorFromEntity(source);
} else if (source instanceof EnderCrystal) {
if (!wcfg.isLogging(Logging.ENDERCRYSTALEXPLOSION)) {
return;
}
actor = Actor.actorFromEntity(source);
} else {
if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
}
for (final Block block : event.blockList()) {
final Material type = block.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && getContainerBlocks().contains(type) && !BukkitUtils.getShulkerBoxBlocks().contains(type)) {
consumer.queueContainerBreak(actor, block.getState());
} else {
consumer.queueBlockBreak(actor, block.getState());
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.hasBlock() && BukkitUtils.isBed(event.getClickedBlock().getType())) {
Block block = event.getClickedBlock();
if (!Config.isLogging(block.getWorld(), Logging.BEDEXPLOSION)) {
return;
}
lastBedInteractionPlayer = event.getPlayer().getUniqueId();
lastBedInteractionLocation = block.getLocation();
new BukkitRunnable() {
@Override
public void run() {
lastBedInteractionPlayer = null;
lastBedInteractionLocation = null;
}
}.runTask(LogBlock.getInstance());
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockExplode(BlockExplodeEvent event) {
Player bedCause = null;
if (lastBedInteractionPlayer != null && lastBedInteractionLocation != null) {
Location block = event.getBlock().getLocation();
if (lastBedInteractionLocation.getWorld() == block.getWorld() && block.distanceSquared(lastBedInteractionLocation) <= 1) {
bedCause = Bukkit.getPlayer(lastBedInteractionPlayer);
}
}
for (final Block block : event.blockList()) {
final WorldConfig wcfg = getWorldConfig(block.getLocation().getWorld());
if (wcfg != null) {
Actor actor = new Actor("Explosion");
if (bedCause != null) {
if (!wcfg.isLogging(Logging.BEDEXPLOSION)) {
return;
}
if (Config.logBedExplosionsAsPlayerWhoTriggeredThese) {
actor = Actor.actorFromEntity(bedCause);
}
} else if (!wcfg.isLogging(Logging.MISCEXPLOSION)) {
return;
}
final Material type = block.getType();
if (wcfg.isLogging(Logging.CHESTACCESS) && getContainerBlocks().contains(type) && !BukkitUtils.getShulkerBoxBlocks().contains(type)) {
consumer.queueContainerBreak(actor, block.getState());
} else {
consumer.queueBlockBreak(actor, block.getState());
}
}
}
}
}

255
src/main/java/de/diddiz/LogBlock/listeners/FluidFlowLogging.java
View File

@ -1,127 +1,128 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Levelled;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFormEvent;
import org.bukkit.event.block.BlockFromToEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class FluidFlowLogging extends LoggingListener {
public FluidFlowLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockFromTo(BlockFromToEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg != null && (wcfg.isLogging(Logging.WATERFLOW) || wcfg.isLogging(Logging.LAVAFLOW))) {
final BlockData blockDataFrom = event.getBlock().getBlockData();
Material typeFrom = blockDataFrom.getMaterial();
boolean fromWaterlogged = false;
if (blockDataFrom instanceof Waterlogged) {
typeFrom = Material.WATER;
fromWaterlogged = true;
}
if (typeFrom == Material.SEAGRASS || typeFrom == Material.KELP_PLANT || typeFrom == Material.KELP) {
typeFrom = Material.WATER;
fromWaterlogged = true;
}
Block source = Config.logFluidFlowAsPlayerWhoTriggeredIt ? event.getBlock() : null;
final Block to = event.getToBlock();
final Material typeTo = to.getType();
boolean down = event.getFace() == BlockFace.DOWN;
final boolean canFlow = BukkitUtils.isEmpty(typeTo) || BukkitUtils.isNonFluidProofBlock(typeTo);
if (typeFrom == Material.LAVA && wcfg.isLogging(Logging.LAVAFLOW)) {
Levelled levelledFrom = (Levelled) blockDataFrom;
if (canFlow) {
if (isSurroundedByWater(to) && levelledFrom.getLevel() <= 2) {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.COBBLESTONE.createBlockData());
} else {
Levelled newBlock = (Levelled) blockDataFrom.clone();
newBlock.setLevel(down ? 1 : Math.min(levelledFrom.getLevel() + 1, levelledFrom.getMaximumLevel()));
if (BukkitUtils.isEmpty(typeTo)) {
consumer.queueBlockPlace(new Actor("LavaFlow", source), to.getLocation(), newBlock);
} else {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), newBlock);
}
}
} else if (typeTo == Material.WATER) {
if (down) {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.STONE.createBlockData());
} else {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.COBBLESTONE.createBlockData());
}
}
} else if ((typeFrom == Material.WATER) && wcfg.isLogging(Logging.WATERFLOW)) {
Levelled levelledFrom = fromWaterlogged ? null : (Levelled) blockDataFrom;
Levelled newBlock = (Levelled) Material.WATER.createBlockData();
newBlock.setLevel(fromWaterlogged || down ? 1 : Math.min(levelledFrom.getLevel() + 1, levelledFrom.getMaximumLevel()));
if (BukkitUtils.isEmpty(typeTo)) {
consumer.queueBlockPlace(new Actor("WaterFlow", source), to.getLocation(), newBlock);
} else if (BukkitUtils.isNonFluidProofBlock(typeTo)) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), newBlock);
} else if (typeTo == Material.LAVA) {
int toLevel = ((Levelled) to.getBlockData()).getLevel();
if (toLevel == 0) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), Material.OBSIDIAN.createBlockData());
} else if (event.getFace() == BlockFace.DOWN) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), Material.STONE.createBlockData());
}
}
if (BukkitUtils.isEmpty(typeTo) || BukkitUtils.isNonFluidProofBlock(typeTo)) {
for (final BlockFace face : new BlockFace[] { BlockFace.DOWN, BlockFace.NORTH, BlockFace.WEST, BlockFace.EAST, BlockFace.SOUTH }) {
final Block lower = to.getRelative(face);
if (lower.getType() == Material.LAVA) {
int toLevel = ((Levelled) lower.getBlockData()).getLevel();
if (toLevel == 0) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), lower.getState(), Material.OBSIDIAN.createBlockData());
} else if (event.getFace() == BlockFace.DOWN) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), lower.getState(), Material.STONE.createBlockData());
}
}
}
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockForm(BlockFormEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg != null && (wcfg.isLogging(Logging.WATERFLOW) || wcfg.isLogging(Logging.LAVAFLOW))) {
if (wcfg.isLogging(Logging.LAVAFLOW) && event.getBlock().getType() == Material.WATER && event.getNewState().getType() == Material.COBBLESTONE) {
consumer.queueBlockReplace(new Actor("LavaFlow"), event.getBlock().getBlockData(), event.getNewState());
}
if (wcfg.isLogging(Logging.WATERFLOW) && event.getBlock().getType() == Material.LAVA) {
consumer.queueBlockReplace(new Actor("WaterFlow"), event.getBlock().getBlockData(), event.getNewState());
}
if (wcfg.isLogging(Logging.WATERFLOW) && BukkitUtils.isConcreteBlock(event.getNewState().getType())) {
consumer.queueBlockReplace(new Actor("WaterFlow"), event.getBlock().getBlockData(), event.getNewState());
}
}
}
private static boolean isSurroundedByWater(Block block) {
for (final BlockFace face : new BlockFace[] { BlockFace.NORTH, BlockFace.WEST, BlockFace.EAST, BlockFace.SOUTH }) {
if (block.getRelative(face).getType() == Material.WATER) {
return true;
}
}
return false;
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Levelled;
import org.bukkit.block.data.Waterlogged;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFormEvent;
import org.bukkit.event.block.BlockFromToEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class FluidFlowLogging extends LoggingListener {
public FluidFlowLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockFromTo(BlockFromToEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg != null && (wcfg.isLogging(Logging.WATERFLOW) || wcfg.isLogging(Logging.LAVAFLOW))) {
final BlockData blockDataFrom = event.getBlock().getBlockData();
Material typeFrom = blockDataFrom.getMaterial();
boolean fromWaterlogged = false;
if (blockDataFrom instanceof Waterlogged) {
typeFrom = Material.WATER;
fromWaterlogged = true;
}
if (typeFrom == Material.SEAGRASS || typeFrom == Material.KELP_PLANT || typeFrom == Material.KELP) {
typeFrom = Material.WATER;
fromWaterlogged = true;
}
Block source = Config.logFluidFlowAsPlayerWhoTriggeredIt ? event.getBlock() : null;
final Block to = event.getToBlock();
final Material typeTo = to.getType();
boolean down = event.getFace() == BlockFace.DOWN;
final boolean canFlow = BukkitUtils.isEmpty(typeTo) || BukkitUtils.getNonFluidProofBlocks().contains(typeTo);
if (typeFrom == Material.LAVA && wcfg.isLogging(Logging.LAVAFLOW)) {
Levelled levelledFrom = (Levelled) blockDataFrom;
if (canFlow) {
if (isSurroundedByWater(to) && levelledFrom.getLevel() <= 2) {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.COBBLESTONE.createBlockData());
} else {
Levelled newBlock = (Levelled) blockDataFrom.clone();
newBlock.setLevel(down ? 1 : levelledFrom.getLevel() + 1);
if (BukkitUtils.isEmpty(typeTo)) {
consumer.queueBlockPlace(new Actor("LavaFlow", source), to.getLocation(), newBlock);
} else {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), newBlock);
}
}
} else if (typeTo == Material.WATER) {
if (down) {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.STONE.createBlockData());
} else {
consumer.queueBlockReplace(new Actor("LavaFlow", source), to.getState(), Material.COBBLESTONE.createBlockData());
}
}
} else if ((typeFrom == Material.WATER) && wcfg.isLogging(Logging.WATERFLOW)) {
Levelled levelledFrom = fromWaterlogged ? null : (Levelled) blockDataFrom;
Levelled newBlock = (Levelled) Material.WATER.createBlockData();
newBlock.setLevel(fromWaterlogged || down ? 1 : levelledFrom.getLevel() + 1);
if (BukkitUtils.isEmpty(typeTo)) {
consumer.queueBlockPlace(new Actor("WaterFlow", source), to.getLocation(), newBlock);
} else if (BukkitUtils.getNonFluidProofBlocks().contains(typeTo)) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), newBlock);
} else if (typeTo == Material.LAVA) {
int toLevel = ((Levelled) to.getBlockData()).getLevel();
if (toLevel == 0) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), Material.OBSIDIAN.createBlockData());
} else if (event.getFace() == BlockFace.DOWN) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), to.getState(), Material.STONE.createBlockData());
}
}
if (BukkitUtils.isEmpty(typeTo) || BukkitUtils.getNonFluidProofBlocks().contains(typeTo)) {
for (final BlockFace face : new BlockFace[] { BlockFace.DOWN, BlockFace.NORTH, BlockFace.WEST, BlockFace.EAST, BlockFace.SOUTH }) {
final Block lower = to.getRelative(face);
if (lower.getType() == Material.LAVA) {
int toLevel = ((Levelled) lower.getBlockData()).getLevel();
if (toLevel == 0) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), lower.getState(), Material.OBSIDIAN.createBlockData());
} else if (event.getFace() == BlockFace.DOWN) {
consumer.queueBlockReplace(new Actor("WaterFlow", source), lower.getState(), Material.STONE.createBlockData());
}
}
}
}
}
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockForm(BlockFormEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getBlock().getWorld());
if (wcfg != null && (wcfg.isLogging(Logging.WATERFLOW) || wcfg.isLogging(Logging.LAVAFLOW))) {
if (wcfg.isLogging(Logging.LAVAFLOW) && event.getBlock().getType() == Material.WATER && event.getNewState().getType() == Material.COBBLESTONE) {
consumer.queueBlockReplace(new Actor("LavaFlow"), event.getBlock().getBlockData(), event.getNewState());
}
if (wcfg.isLogging(Logging.WATERFLOW) && event.getBlock().getType() == Material.LAVA) {
consumer.queueBlockReplace(new Actor("WaterFlow"), event.getBlock().getBlockData(), event.getNewState());
}
if (wcfg.isLogging(Logging.WATERFLOW) && BukkitUtils.isConcreteBlock(event.getNewState().getType())) {
consumer.queueBlockReplace(new Actor("WaterFlow"), event.getBlock().getBlockData(), event.getNewState());
}
}
}
private static boolean isSurroundedByWater(Block block) {
for (final BlockFace face : new BlockFace[] { BlockFace.NORTH, BlockFace.WEST, BlockFace.EAST, BlockFace.SOUTH }) {
if (block.getRelative(face).getType() == Material.WATER) {
return true;
}
}
return false;
}
}

532
src/main/java/de/diddiz/LogBlock/listeners/InteractLogging.java
View File

@ -1,274 +1,258 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.LogBlock.util.BukkitUtils;
import java.util.UUID;
import org.bukkit.DyeColor;
import org.bukkit.GameEvent;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Note;
import org.bukkit.Note.Tone;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Directional;
import org.bukkit.block.data.Lightable;
import org.bukkit.block.data.Openable;
import org.bukkit.block.data.type.Cake;
import org.bukkit.block.data.type.Candle;
import org.bukkit.block.data.type.Comparator;
import org.bukkit.block.data.type.Comparator.Mode;
import org.bukkit.block.data.type.DaylightDetector;
import org.bukkit.block.data.type.Door;
import org.bukkit.block.data.type.NoteBlock;
import org.bukkit.block.data.type.Repeater;
import org.bukkit.block.data.type.Switch;
import org.bukkit.block.data.type.TurtleEgg;
import org.bukkit.block.sign.Side;
import org.bukkit.block.sign.SignSide;
import org.bukkit.entity.Player;
import org.bukkit.event.Event.Result;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.world.GenericGameEvent;
import org.bukkit.inventory.ItemStack;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class InteractLogging extends LoggingListener {
public InteractLogging(LogBlock lb) {
super(lb);
}
private UUID lastInteractionPlayer;
private BlockData lastInteractionBlockData;
private Location lastInteractionLocation;
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteract(PlayerInteractEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getPlayer().getWorld());
if (wcfg != null) {
final Block clicked = event.getClickedBlock();
if (clicked == null) {
return;
}
final BlockData blockData = clicked.getBlockData();
final Material type = blockData.getMaterial();
final Player player = event.getPlayer();
final Location loc = clicked.getLocation();
lastInteractionPlayer = player.getUniqueId();
lastInteractionBlockData = blockData;
lastInteractionLocation = loc;
if (BukkitUtils.isFenceGate(type) || BukkitUtils.isWoodenTrapdoor(type)) {
if (wcfg.isLogging(Logging.DOORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Openable newBlockData = (Openable) blockData.clone();
newBlockData.setOpen(!newBlockData.isOpen());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (BukkitUtils.isPressurePlate(type)) {
if (wcfg.isLogging(Logging.PRESUREPLATEINTERACT) && event.getAction() == Action.PHYSICAL) {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, blockData);
}
} else if (BukkitUtils.isWoodenDoor(type)) {
if (wcfg.isLogging(Logging.DOORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Door newBlockData = (Door) blockData.clone();
newBlockData.setOpen(!newBlockData.isOpen());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (BukkitUtils.isButton(type) || type == Material.LEVER) {
if (wcfg.isLogging(Logging.SWITCHINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Switch newBlockData = (Switch) blockData.clone();
if (!newBlockData.isPowered() || type == Material.LEVER) {
newBlockData.setPowered(!newBlockData.isPowered());
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (BukkitUtils.isSign(type)) {
if (wcfg.isLogging(Logging.SIGNTEXT) && event.getAction() == Action.RIGHT_CLICK_BLOCK && event.getItem() != null) {
Material itemType = event.getItem().getType();
if (BukkitUtils.isDye(itemType) || itemType == Material.GLOW_INK_SAC || itemType == Material.INK_SAC || itemType == Material.HONEYCOMB) {
final BlockState before = event.getClickedBlock().getState();
if (before instanceof Sign signBefore) {
if (!signBefore.isWaxed()) {
final Sign signAfter = (Sign) event.getClickedBlock().getState();
Side side = BukkitUtils.getFacingSignSide(player, clicked);
SignSide signSideBefore = signBefore.getSide(side);
SignSide signSideAfter = signAfter.getSide(side);
if (itemType == Material.GLOW_INK_SAC) {
if (!signSideBefore.isGlowingText() && hasText(signSideBefore)) {
signSideAfter.setGlowingText(true);
consumer.queueBlockReplace(Actor.actorFromEntity(player), signBefore, signAfter);
}
} else if (itemType == Material.INK_SAC) {
if (signSideBefore.isGlowingText() && hasText(signSideBefore)) {
signSideAfter.setGlowingText(false);
consumer.queueBlockReplace(Actor.actorFromEntity(player), signBefore, signAfter);
}
} else if (itemType == Material.HONEYCOMB) {
signAfter.setWaxed(true);
consumer.queueBlockReplace(Actor.actorFromEntity(player), signBefore, signAfter);
} else if (BukkitUtils.isDye(itemType) && hasText(signSideBefore)) {
DyeColor newColor = BukkitUtils.dyeToDyeColor(itemType);
if (newColor != null && signSideBefore.getColor() != newColor) {
signSideAfter.setColor(newColor);
consumer.queueBlockReplace(Actor.actorFromEntity(player), signBefore, signAfter);
}
}
}
}
}
}
} else if (type == Material.CAKE) {
if (event.hasItem() && BukkitUtils.isCandle(event.getItem().getType()) && event.useItemInHand() != Result.DENY) {
BlockData newBlockData = Material.valueOf(event.getItem().getType().name() + "_CAKE").createBlockData();
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
} else if (wcfg.isLogging(Logging.CAKEEAT) && event.getAction() == Action.RIGHT_CLICK_BLOCK && player.getFoodLevel() < 20) {
Cake newBlockData = (Cake) blockData.clone();
if (newBlockData.getBites() < 6) {
newBlockData.setBites(newBlockData.getBites() + 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
} else {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, Material.AIR.createBlockData());
}
}
} else if (type == Material.NOTE_BLOCK) {
if (wcfg.isLogging(Logging.NOTEBLOCKINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
NoteBlock newBlockData = (NoteBlock) blockData.clone();
if (newBlockData.getNote().getOctave() == 2) {
newBlockData.setNote(new Note(0, Tone.F, true));
} else {
newBlockData.setNote(newBlockData.getNote().sharped());
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (type == Material.REPEATER) {
if (wcfg.isLogging(Logging.DIODEINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Repeater newBlockData = (Repeater) blockData.clone();
newBlockData.setDelay((newBlockData.getDelay() % 4) + 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (type == Material.COMPARATOR) {
if (wcfg.isLogging(Logging.COMPARATORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Comparator newBlockData = (Comparator) blockData.clone();
newBlockData.setMode(newBlockData.getMode() == Mode.COMPARE ? Mode.SUBTRACT : Mode.COMPARE);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (type == Material.DAYLIGHT_DETECTOR) {
if (wcfg.isLogging(Logging.DAYLIGHTDETECTORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
DaylightDetector newBlockData = (DaylightDetector) blockData.clone();
newBlockData.setInverted(!newBlockData.isInverted());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
} else if (type == Material.TRIPWIRE) {
if (wcfg.isLogging(Logging.TRIPWIREINTERACT) && event.getAction() == Action.PHYSICAL) {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, blockData);
}
} else if (type == Material.FARMLAND) {
if (wcfg.isLogging(Logging.CROPTRAMPLE) && event.getAction() == Action.PHYSICAL) {
// 3 = Dirt ID
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, Material.DIRT.createBlockData());
// Log the crop on top as being broken
Block trampledCrop = clicked.getRelative(BlockFace.UP);
if (BukkitUtils.isCropBlock(trampledCrop.getType())) {
consumer.queueBlockBreak(Actor.actorFromEntity(player), trampledCrop.getState());
}
}
} else if (type == Material.TURTLE_EGG) {
if (wcfg.isLogging(Logging.BLOCKBREAK) && event.getAction() == Action.PHYSICAL) {
TurtleEgg turtleEggData = (TurtleEgg) blockData;
int eggs = turtleEggData.getEggs();
if (eggs > 1) {
TurtleEgg turtleEggData2 = (TurtleEgg) turtleEggData.clone();
turtleEggData2.setEggs(eggs - 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, turtleEggData, turtleEggData2);
} else {
consumer.queueBlock(Actor.actorFromEntity(player), loc, turtleEggData, Material.AIR.createBlockData());
}
}
} else if (type == Material.PUMPKIN) {
if ((wcfg.isLogging(Logging.BLOCKBREAK) || wcfg.isLogging(Logging.BLOCKPLACE)) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
ItemStack inHand = event.getItem();
if (inHand != null && inHand.getType() == Material.SHEARS) {
BlockFace clickedFace = event.getBlockFace();
Directional newBlockData = (Directional) Material.CARVED_PUMPKIN.createBlockData();
if (clickedFace == BlockFace.NORTH || clickedFace == BlockFace.SOUTH || clickedFace == BlockFace.EAST || clickedFace == BlockFace.WEST) {
newBlockData.setFacing(clickedFace);
} else {
// use player distance to calculate the facing
Location playerLoc = player.getLocation();
playerLoc.subtract(0.5, 0, 0.5);
double dx = playerLoc.getX() - loc.getX();
double dz = playerLoc.getZ() - loc.getZ();
if (Math.abs(dx) > Math.abs(dz)) {
newBlockData.setFacing(dx > 0 ? BlockFace.EAST : BlockFace.WEST);
} else {
newBlockData.setFacing(dz > 0 ? BlockFace.SOUTH : BlockFace.NORTH);
}
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
}
}
}
}
private boolean hasText(SignSide signSide) {
for (int i = 0; i < 4; i++) {
if (!signSide.getLine(i).isEmpty()) {
return true;
}
}
return false;
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onGenericGameEvent(GenericGameEvent event) {
if (lastInteractionPlayer != null && event.getEntity() != null && event.getEntity().getUniqueId().equals(lastInteractionPlayer) && lastInteractionLocation != null && event.getLocation().equals(lastInteractionLocation)) {
if (lastInteractionBlockData instanceof Candle) {
Candle previousCandle = (Candle) lastInteractionBlockData;
if (previousCandle.isLit()) {
BlockData newData = lastInteractionLocation.getBlock().getBlockData();
if (newData instanceof Candle) {
Candle newCandle = (Candle) newData;
if (!newCandle.isLit() && !newCandle.isWaterlogged()) {
// log candle extinguish
consumer.queueBlockReplace(Actor.actorFromEntity(event.getEntity()), lastInteractionLocation, lastInteractionBlockData, newData);
}
}
}
} else if (lastInteractionBlockData instanceof Lightable && BukkitUtils.isCandleCake(lastInteractionBlockData.getMaterial())) {
Lightable previousLightable = (Lightable) lastInteractionBlockData;
BlockData newData = lastInteractionLocation.getBlock().getBlockData();
if (event.getEvent().equals(GameEvent.EAT)) {
final WorldConfig wcfg = getWorldConfig(event.getLocation().getWorld());
if (wcfg.isLogging(Logging.CAKEEAT)) {
// nom nom (don't know why newData is incorrect here)
newData = Material.CAKE.createBlockData();
((Cake) newData).setBites(1);
consumer.queueBlockReplace(Actor.actorFromEntity(event.getEntity()), lastInteractionLocation, lastInteractionBlockData, newData);
}
} else if (previousLightable.isLit()) {
if (newData instanceof Lightable) {
Lightable newLightable = (Lightable) newData;
if (!newLightable.isLit()) {
// log cake extinguish
consumer.queueBlockReplace(Actor.actorFromEntity(event.getEntity()), lastInteractionLocation, lastInteractionBlockData, newData);
}
}
}
}
}
lastInteractionPlayer = null;
lastInteractionBlockData = null;
lastInteractionLocation = null;
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import de.diddiz.util.BukkitUtils;
import org.bukkit.DyeColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Note;
import org.bukkit.Note.Tone;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Directional;
import org.bukkit.block.data.Openable;
import org.bukkit.block.data.type.Cake;
import org.bukkit.block.data.type.Comparator;
import org.bukkit.block.data.type.Comparator.Mode;
import org.bukkit.block.data.type.DaylightDetector;
import org.bukkit.block.data.type.Door;
import org.bukkit.block.data.type.NoteBlock;
import org.bukkit.block.data.type.Repeater;
import org.bukkit.block.data.type.Switch;
import org.bukkit.block.data.type.TurtleEgg;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class InteractLogging extends LoggingListener {
public InteractLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerInteract(PlayerInteractEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getPlayer().getWorld());
if (wcfg != null) {
final Block clicked = event.getClickedBlock();
if (clicked == null) {
return;
}
final BlockData blockData = clicked.getBlockData();
final Material type = blockData.getMaterial();
final Player player = event.getPlayer();
final Location loc = clicked.getLocation();
switch (type) {
case OAK_FENCE_GATE:
case SPRUCE_FENCE_GATE:
case BIRCH_FENCE_GATE:
case JUNGLE_FENCE_GATE:
case ACACIA_FENCE_GATE:
case DARK_OAK_FENCE_GATE:
case WARPED_FENCE_GATE:
case CRIMSON_FENCE_GATE:
case OAK_TRAPDOOR:
case SPRUCE_TRAPDOOR:
case BIRCH_TRAPDOOR:
case JUNGLE_TRAPDOOR:
case ACACIA_TRAPDOOR:
case DARK_OAK_TRAPDOOR:
case WARPED_TRAPDOOR:
case CRIMSON_TRAPDOOR:
if (wcfg.isLogging(Logging.DOORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Openable newBlockData = (Openable) blockData.clone();
newBlockData.setOpen(!newBlockData.isOpen());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case CAKE:
if (wcfg.isLogging(Logging.CAKEEAT) && event.getAction() == Action.RIGHT_CLICK_BLOCK && player.getFoodLevel() < 20) {
Cake newBlockData = (Cake) blockData.clone();
if (newBlockData.getBites() < 6) {
newBlockData.setBites(newBlockData.getBites() + 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
} else {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, Material.AIR.createBlockData());
}
}
break;
case NOTE_BLOCK:
if (wcfg.isLogging(Logging.NOTEBLOCKINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
NoteBlock newBlockData = (NoteBlock) blockData.clone();
if (newBlockData.getNote().getOctave() == 2) {
newBlockData.setNote(new Note(0, Tone.F, true));
} else {
newBlockData.setNote(newBlockData.getNote().sharped());
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case REPEATER:
if (wcfg.isLogging(Logging.DIODEINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Repeater newBlockData = (Repeater) blockData.clone();
newBlockData.setDelay((newBlockData.getDelay() % 4) + 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case COMPARATOR:
if (wcfg.isLogging(Logging.COMPARATORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Comparator newBlockData = (Comparator) blockData.clone();
newBlockData.setMode(newBlockData.getMode() == Mode.COMPARE ? Mode.SUBTRACT : Mode.COMPARE);
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case DAYLIGHT_DETECTOR:
if (wcfg.isLogging(Logging.DAYLIGHTDETECTORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
DaylightDetector newBlockData = (DaylightDetector) blockData.clone();
newBlockData.setInverted(!newBlockData.isInverted());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case OAK_PRESSURE_PLATE:
case SPRUCE_PRESSURE_PLATE:
case BIRCH_PRESSURE_PLATE:
case JUNGLE_PRESSURE_PLATE:
case ACACIA_PRESSURE_PLATE:
case DARK_OAK_PRESSURE_PLATE:
case WARPED_PRESSURE_PLATE:
case CRIMSON_PRESSURE_PLATE:
case STONE_PRESSURE_PLATE:
case HEAVY_WEIGHTED_PRESSURE_PLATE:
case LIGHT_WEIGHTED_PRESSURE_PLATE:
if (wcfg.isLogging(Logging.PRESUREPLATEINTERACT) && event.getAction() == Action.PHYSICAL) {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, blockData);
}
break;
case TRIPWIRE:
if (wcfg.isLogging(Logging.TRIPWIREINTERACT) && event.getAction() == Action.PHYSICAL) {
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, blockData);
}
break;
case FARMLAND:
if (wcfg.isLogging(Logging.CROPTRAMPLE) && event.getAction() == Action.PHYSICAL) {
// 3 = Dirt ID
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, Material.DIRT.createBlockData());
// Log the crop on top as being broken
Block trampledCrop = clicked.getRelative(BlockFace.UP);
if (BukkitUtils.getCropBlocks().contains(trampledCrop.getType())) {
consumer.queueBlockBreak(Actor.actorFromEntity(player), trampledCrop.getState());
}
}
break;
case TURTLE_EGG:
if (wcfg.isLogging(Logging.BLOCKBREAK) && event.getAction() == Action.PHYSICAL) {
TurtleEgg turtleEggData = (TurtleEgg) blockData;
int eggs = turtleEggData.getEggs();
if (eggs > 1) {
TurtleEgg turtleEggData2 = (TurtleEgg) turtleEggData.clone();
turtleEggData2.setEggs(eggs - 1);
consumer.queueBlock(Actor.actorFromEntity(player), loc, turtleEggData, turtleEggData2);
} else {
consumer.queueBlock(Actor.actorFromEntity(player), loc, turtleEggData, Material.AIR.createBlockData());
}
}
break;
case PUMPKIN:
if ((wcfg.isLogging(Logging.BLOCKBREAK) || wcfg.isLogging(Logging.BLOCKPLACE)) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
ItemStack inHand = event.getItem();
if (inHand != null && inHand.getType() == Material.SHEARS) {
BlockFace clickedFace = event.getBlockFace();
Directional newBlockData = (Directional) Material.CARVED_PUMPKIN.createBlockData();
if (clickedFace == BlockFace.NORTH || clickedFace == BlockFace.SOUTH || clickedFace == BlockFace.EAST || clickedFace == BlockFace.WEST) {
newBlockData.setFacing(clickedFace);
} else {
// use player distance to calculate the facing
Location playerLoc = player.getLocation();
playerLoc.subtract(0.5, 0, 0.5);
double dx = playerLoc.getX() - loc.getX();
double dz = playerLoc.getZ() - loc.getZ();
if (Math.abs(dx) > Math.abs(dz)) {
newBlockData.setFacing(dx > 0 ? BlockFace.EAST : BlockFace.WEST);
} else {
newBlockData.setFacing(dz > 0 ? BlockFace.SOUTH : BlockFace.NORTH);
}
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
}
break;
case OAK_DOOR:
case SPRUCE_DOOR:
case BIRCH_DOOR:
case JUNGLE_DOOR:
case ACACIA_DOOR:
case DARK_OAK_DOOR:
case WARPED_DOOR:
case CRIMSON_DOOR:
if (wcfg.isLogging(Logging.DOORINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Door newBlockData = (Door) blockData.clone();
newBlockData.setOpen(!newBlockData.isOpen());
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case STONE_BUTTON:
case OAK_BUTTON:
case SPRUCE_BUTTON:
case BIRCH_BUTTON:
case JUNGLE_BUTTON:
case ACACIA_BUTTON:
case DARK_OAK_BUTTON:
case WARPED_BUTTON:
case CRIMSON_BUTTON:
case LEVER:
if (wcfg.isLogging(Logging.SWITCHINTERACT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
Switch newBlockData = (Switch) blockData.clone();
if (!newBlockData.isPowered() || type == Material.LEVER) {
newBlockData.setPowered(!newBlockData.isPowered());
}
consumer.queueBlock(Actor.actorFromEntity(player), loc, blockData, newBlockData);
}
break;
case OAK_SIGN:
case SPRUCE_SIGN:
case BIRCH_SIGN:
case JUNGLE_SIGN:
case ACACIA_SIGN:
case DARK_OAK_SIGN:
case WARPED_SIGN:
case CRIMSON_SIGN:
case OAK_WALL_SIGN:
case SPRUCE_WALL_SIGN:
case BIRCH_WALL_SIGN:
case JUNGLE_WALL_SIGN:
case ACACIA_WALL_SIGN:
case DARK_OAK_WALL_SIGN:
case WARPED_WALL_SIGN:
case CRIMSON_WALL_SIGN:
if (wcfg.isLogging(Logging.SIGNTEXT) && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
ItemStack stack = event.getItem();
if (stack != null && BukkitUtils.isDye(stack.getType())) {
final BlockState before = event.getClickedBlock().getState();
if (before instanceof Sign) {
DyeColor newColor = BukkitUtils.dyeToDyeColor(stack.getType());
Sign signBefore = (Sign) before;
if (newColor != null && signBefore.getColor() != newColor) {
final Sign signAfter = (Sign) event.getClickedBlock().getState();
signAfter.setColor(newColor);
consumer.queueBlockReplace(Actor.actorFromEntity(player), signBefore, signAfter);
}
}
}
}
break;
default:
}
}
}
}

100
src/main/java/de/diddiz/LogBlock/listeners/KillLogging.java
View File

@ -1,51 +1,49 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config.*;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Monster;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import static de.diddiz.LogBlock.config.Config.*;
public class KillLogging extends LoggingListener {
public KillLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent deathEvent) {
EntityDamageEvent event = deathEvent.getEntity().getLastDamageCause();
// For a death event, there should always be a damage event and it should not be cancelled. Check anyway.
if (event != null && event.isCancelled() == false && isLogging(event.getEntity().getWorld(), Logging.KILL) && event.getEntity() instanceof LivingEntity) {
final LivingEntity victim = (LivingEntity) event.getEntity();
if (event instanceof EntityDamageByEntityEvent) {
final Entity killer = ((EntityDamageByEntityEvent) event).getDamager();
if (logKillsLevel == LogKillsLevel.PLAYERS && !(victim instanceof Player && killer instanceof Player)) {
return;
} else if (logKillsLevel == LogKillsLevel.MONSTERS && !((victim instanceof Player || victim instanceof Monster) && killer instanceof Player || killer instanceof Monster)) {
return;
}
consumer.queueKill(killer, victim);
} else if (deathEvent.getEntity().getKiller() != null) {
consumer.queueKill(deathEvent.getEntity().getKiller(), victim);
} else if (logEnvironmentalKills) {
if (logKillsLevel == LogKillsLevel.PLAYERS && !(victim instanceof Player)) {
return;
} else if (logKillsLevel == LogKillsLevel.MONSTERS && !((victim instanceof Player || victim instanceof Monster))) {
return;
}
consumer.queueKill(new Actor(event.getCause().toString()), victim);
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.Config.*;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Monster;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import static de.diddiz.LogBlock.config.Config.*;
public class KillLogging extends LoggingListener {
public KillLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent deathEvent) {
EntityDamageEvent event = deathEvent.getEntity().getLastDamageCause();
// For a death event, there should always be a damage event and it should not be cancelled. Check anyway.
if (event != null && event.isCancelled() == false && isLogging(event.getEntity().getWorld(), Logging.KILL) && event.getEntity() instanceof LivingEntity) {
final LivingEntity victim = (LivingEntity) event.getEntity();
if (event instanceof EntityDamageByEntityEvent) {
final Entity killer = ((EntityDamageByEntityEvent) event).getDamager();
if (logKillsLevel == LogKillsLevel.PLAYERS && !(victim instanceof Player && killer instanceof Player)) {
return;
} else if (logKillsLevel == LogKillsLevel.MONSTERS && !((victim instanceof Player || victim instanceof Monster) && killer instanceof Player || killer instanceof Monster)) {
return;
}
consumer.queueKill(killer, victim);
} else if (logEnvironmentalKills) {
if (logKillsLevel == LogKillsLevel.PLAYERS && !(victim instanceof Player)) {
return;
} else if (logKillsLevel == LogKillsLevel.MONSTERS && !((victim instanceof Player || victim instanceof Monster))) {
return;
}
consumer.queueKill(new Actor(event.getCause().toString()), victim);
}
}
}
}

52
src/main/java/de/diddiz/LogBlock/listeners/LeavesDecayLogging.java
View File

@ -1,26 +1,26 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.LeavesDecayEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogFallables;
public class LeavesDecayLogging extends LoggingListener {
public LeavesDecayLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onLeavesDecay(LeavesDecayEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.LEAVESDECAY)) {
smartLogBlockBreak(consumer, new Actor("LeavesDecay"), event.getBlock());
smartLogFallables(consumer, new Actor("LeavesDecay"), event.getBlock());
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.LeavesDecayEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.util.LoggingUtil.smartLogBlockBreak;
import static de.diddiz.util.LoggingUtil.smartLogFallables;
public class LeavesDecayLogging extends LoggingListener {
public LeavesDecayLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onLeavesDecay(LeavesDecayEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.LEAVESDECAY)) {
smartLogBlockBreak(consumer, new Actor("LeavesDecay"), event.getBlock());
smartLogFallables(consumer, new Actor("LeavesDecay"), event.getBlock());
}
}
}

26
src/main/java/de/diddiz/LogBlock/listeners/LoggingListener.java
View File

@ -1,13 +1,13 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Consumer;
import de.diddiz.LogBlock.LogBlock;
import org.bukkit.event.Listener;
public class LoggingListener implements Listener {
protected final Consumer consumer;
public LoggingListener(LogBlock lb) {
consumer = lb.getConsumer();
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Consumer;
import de.diddiz.LogBlock.LogBlock;
import org.bukkit.event.Listener;
public class LoggingListener implements Listener {
protected final Consumer consumer;
public LoggingListener(LogBlock lb) {
consumer = lb.getConsumer();
}
}

28
src/main/java/de/diddiz/LogBlock/listeners/OxidizationLogging.java
View File

@ -1,28 +0,0 @@
package de.diddiz.LogBlock.listeners;
import static de.diddiz.LogBlock.config.Config.isLogging;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFormEvent;
public class OxidizationLogging extends LoggingListener {
public OxidizationLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPhysics(BlockFormEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.OXIDIZATION)) {
final Material type = event.getNewState().getType();
if (type.name().contains("COPPER")) {
consumer.queueBlockReplace(new Actor("NaturalOxidization"), event.getBlock().getState(), event.getNewState());
}
}
}
}

86
src/main/java/de/diddiz/LogBlock/listeners/PlayerInfoLogging.java
View File

@ -1,43 +1,43 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.config.Config;
import java.util.HashMap;
import java.util.UUID;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
public class PlayerInfoLogging extends LoggingListener {
private final HashMap<UUID, Long> playerLogins = new HashMap<>();
public PlayerInfoLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerJoin(PlayerJoinEvent event) {
playerLogins.put(event.getPlayer().getUniqueId(), System.currentTimeMillis());
consumer.queueJoin(event.getPlayer());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerQuit(PlayerQuitEvent event) {
onPlayerQuit(event.getPlayer());
}
public void onPlayerQuit(Player player) {
Long joinTime = playerLogins.remove(player.getUniqueId());
if (Config.logPlayerInfo && joinTime != null) {
long onlineTime = (System.currentTimeMillis() - joinTime) / 1000;
if (onlineTime > 0) {
consumer.queueLeave(player, onlineTime);
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.config.Config;
import java.util.HashMap;
import java.util.UUID;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
public class PlayerInfoLogging extends LoggingListener {
private final HashMap<UUID, Long> playerLogins = new HashMap<>();
public PlayerInfoLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerJoin(PlayerJoinEvent event) {
playerLogins.put(event.getPlayer().getUniqueId(), System.currentTimeMillis());
consumer.queueJoin(event.getPlayer());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerQuit(PlayerQuitEvent event) {
onPlayerQuit(event.getPlayer());
}
public void onPlayerQuit(Player player) {
Long joinTime = playerLogins.remove(player.getUniqueId());
if (Config.logPlayerInfo && joinTime != null) {
long onlineTime = (System.currentTimeMillis() - joinTime) / 1000;
if (onlineTime > 0) {
consumer.queueLeave(player, onlineTime);
}
}
}
}

2
src/main/java/de/diddiz/LogBlock/listeners/ScaffoldingLogging.java
View File

@ -18,7 +18,7 @@ import org.bukkit.event.block.BlockFadeEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
import static de.diddiz.LogBlock.util.LoggingUtil.smartLogFallables;
import static de.diddiz.util.LoggingUtil.smartLogFallables;
public class ScaffoldingLogging extends LoggingListener {
private final static long MAX_SCAFFOLDING_LOG_TIME_MS = 2000;

63
src/main/java/de/diddiz/LogBlock/listeners/SignChangeLogging.java
View File

@ -1,40 +1,23 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import java.util.Objects;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.block.sign.SignSide;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.SignChangeEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SignChangeLogging extends LoggingListener {
public SignChangeLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onSignChange(SignChangeEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SIGNTEXT)) {
BlockState newState = event.getBlock().getState();
if (newState instanceof Sign sign) {
SignSide signSide = sign.getSide(event.getSide());
boolean changed = false;
for (int i = 0; i < 4; i++) {
if (!Objects.equals(signSide.getLine(i), event.getLine(i))) {
signSide.setLine(i, event.getLine(i));
changed = true;
}
}
if (changed) {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getPlayer()), event.getBlock().getState(), newState);
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.SignChangeEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SignChangeLogging extends LoggingListener {
public SignChangeLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onSignChange(SignChangeEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SIGNTEXT)) {
consumer.queueSignChange(Actor.actorFromEntity(event.getPlayer()), event.getBlock().getLocation(), event.getBlock().getBlockData(), event.getLines());
}
}
}

56
src/main/java/de/diddiz/LogBlock/listeners/SnowFadeLogging.java
View File

@ -1,28 +1,28 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFadeEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SnowFadeLogging extends LoggingListener {
public SnowFadeLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockFade(BlockFadeEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SNOWFADE)) {
final Material type = event.getBlock().getType();
if (type == Material.SNOW || type == Material.ICE) {
consumer.queueBlockReplace(new Actor("SnowFade"), event.getBlock().getState(), event.getNewState());
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFadeEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SnowFadeLogging extends LoggingListener {
public SnowFadeLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockFade(BlockFadeEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SNOWFADE)) {
final Material type = event.getBlock().getType();
if (type == Material.SNOW || type == Material.ICE) {
consumer.queueBlockReplace(new Actor("SnowFade"), event.getBlock().getState(), event.getNewState());
}
}
}
}

56
src/main/java/de/diddiz/LogBlock/listeners/SnowFormLogging.java
View File

@ -1,28 +1,28 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFormEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SnowFormLogging extends LoggingListener {
public SnowFormLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockForm(BlockFormEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SNOWFORM)) {
final Material type = event.getNewState().getType();
if (type == Material.SNOW || type == Material.ICE) {
consumer.queueBlockReplace(new Actor("SnowForm"), event.getBlock().getState(), event.getNewState());
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockFormEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class SnowFormLogging extends LoggingListener {
public SnowFormLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockForm(BlockFormEvent event) {
if (isLogging(event.getBlock().getWorld(), Logging.SNOWFORM)) {
final Material type = event.getNewState().getType();
if (type == Material.SNOW || type == Material.ICE) {
consumer.queueBlockReplace(new Actor("SnowForm"), event.getBlock().getState(), event.getNewState());
}
}
}
}

74
src/main/java/de/diddiz/LogBlock/listeners/StructureGrowLogging.java
View File

@ -1,34 +1,40 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import org.bukkit.block.BlockState;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.world.StructureGrowEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class StructureGrowLogging extends LoggingListener {
public StructureGrowLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onStructureGrow(StructureGrowEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getWorld());
if (wcfg != null) {
if (!wcfg.isLogging(Logging.NATURALSTRUCTUREGROW)) {
return;
}
if (!event.isFromBonemeal()) {
final Actor actor = new Actor("NaturalGrow");
for (final BlockState state : event.getBlocks()) {
consumer.queueBlockReplace(actor, state.getBlock().getState(), state);
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.config.WorldConfig;
import org.bukkit.block.BlockState;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.world.StructureGrowEvent;
import static de.diddiz.LogBlock.config.Config.getWorldConfig;
public class StructureGrowLogging extends LoggingListener {
public StructureGrowLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onStructureGrow(StructureGrowEvent event) {
final WorldConfig wcfg = getWorldConfig(event.getWorld());
if (wcfg != null) {
final Actor actor;
if (event.getPlayer() != null) {
if (!wcfg.isLogging(Logging.BONEMEALSTRUCTUREGROW)) {
return;
}
actor = Actor.actorFromEntity(event.getPlayer());
} else {
if (!wcfg.isLogging(Logging.NATURALSTRUCTUREGROW)) {
return;
}
actor = new Actor("NaturalGrow");
}
for (final BlockState state : event.getBlocks()) {
consumer.queueBlockReplace(actor, state.getBlock().getState(), state);
}
}
}
}

302
src/main/java/de/diddiz/LogBlock/listeners/ToolListener.java
View File

@ -1,151 +1,151 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.*;
import de.diddiz.LogBlock.events.ToolUseEvent;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.LogBlock.util.CuboidRegion;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import java.util.Map.Entry;
import static de.diddiz.LogBlock.Session.getSession;
import static de.diddiz.LogBlock.Session.hasSession;
import static de.diddiz.LogBlock.config.Config.isLogged;
import static de.diddiz.LogBlock.config.Config.toolsByType;
public class ToolListener implements Listener {
private final CommandsHandler handler;
private final LogBlock logblock;
public ToolListener(LogBlock logblock) {
this.logblock = logblock;
handler = logblock.getCommandsHandler();
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getMaterial() != null) {
final Action action = event.getAction();
final Material type = event.getMaterial();
final Tool tool = toolsByType.get(type);
final Player player = event.getPlayer();
if (tool != null && (action == Action.RIGHT_CLICK_BLOCK || action == Action.LEFT_CLICK_BLOCK) && logblock.hasPermission(player, "logblock.tools." + tool.name)) {
final ToolBehavior behavior = action == Action.RIGHT_CLICK_BLOCK ? tool.rightClickBehavior : tool.leftClickBehavior;
final ToolData toolData = getSession(player).toolData.get(tool);
if (behavior != ToolBehavior.NONE && toolData.enabled) {
if (!isLogged(player.getWorld())) {
player.sendMessage(ChatColor.RED + "This world is not currently logged.");
event.setCancelled(true);
return;
}
final Block block = event.getClickedBlock();
final QueryParams params = toolData.params.clone();
params.loc = null;
params.sel = null;
if (behavior == ToolBehavior.BLOCK) {
params.setLocation(block.getRelative(event.getBlockFace()).getLocation());
} else if (tool.params.radius != 0) {
params.setLocation(block.getLocation());
} else {
Block otherHalfChest = BukkitUtils.getConnectedChest(block);
if (otherHalfChest == null) {
params.setLocation(block.getLocation());
} else {
params.setSelection(CuboidRegion.fromCorners(block.getLocation().getWorld(), block.getLocation(), otherHalfChest.getLocation()));
}
}
try {
params.validate();
if (this.callToolUseEvent(new ToolUseEvent(player, tool, behavior, params))) {
return;
}
if (toolData.mode == ToolMode.ROLLBACK) {
handler.new CommandRollback(player, params, true);
} else if (toolData.mode == ToolMode.REDO) {
handler.new CommandRedo(player, params, true);
} else if (toolData.mode == ToolMode.CLEARLOG) {
handler.new CommandClearLog(player, params, true);
} else if (toolData.mode == ToolMode.WRITELOGFILE) {
handler.new CommandWriteLogFile(player, params, true);
} else {
handler.new CommandLookup(player, params, true);
}
} catch (final Exception ex) {
player.sendMessage(ChatColor.RED + ex.getMessage());
}
event.setCancelled(true);
}
}
}
}
private boolean callToolUseEvent(ToolUseEvent event) {
this.logblock.getServer().getPluginManager().callEvent(event);
return event.isCancelled();
}
@EventHandler
public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
final Player player = event.getPlayer();
if (hasSession(player)) {
final Session session = getSession(player);
for (final Entry<Tool, ToolData> entry : session.toolData.entrySet()) {
final Tool tool = entry.getKey();
final ToolData toolData = entry.getValue();
if (toolData.enabled && !logblock.hasPermission(player, "logblock.tools." + tool.name)) {
toolData.enabled = false;
if (tool.removeOnDisable && logblock.hasPermission(player, "logblock.spawnTools")) {
player.getInventory().removeItem(new ItemStack(tool.item, 1));
}
player.sendMessage(ChatColor.GREEN + "Tool disabled.");
}
}
}
}
@EventHandler
public void onPlayerDropItem(PlayerDropItemEvent event) {
final Player player = event.getPlayer();
if (hasSession(player)) {
final Session session = getSession(player);
for (final Entry<Tool, ToolData> entry : session.toolData.entrySet()) {
final Tool tool = entry.getKey();
final ToolData toolData = entry.getValue();
final Material item = event.getItemDrop().getItemStack().getType();
if (item == tool.item && toolData.enabled) {
if (tool.dropToDisable) {
toolData.enabled = false;
ItemStack stack = event.getItemDrop().getItemStack();
if (tool.removeOnDisable && logblock.hasPermission(player, "logblock.spawnTools")) {
if (stack.isSimilar(new ItemStack(item))) {
if (stack.getAmount() > 1) {
stack.setAmount(stack.getAmount() - 1);
event.getItemDrop().setItemStack(stack);
} else {
event.getItemDrop().remove();
}
}
}
if (BukkitUtils.hasInventoryStorageSpaceFor(player.getInventory(), stack)) {
event.setCancelled(true);
}
player.sendMessage(ChatColor.GREEN + "Tool disabled.");
} else if (!tool.canDrop) {
player.sendMessage(ChatColor.RED + "You cannot drop this tool.");
event.setCancelled(true);
}
}
}
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.*;
import de.diddiz.LogBlock.events.ToolUseEvent;
import de.diddiz.util.BukkitUtils;
import de.diddiz.util.CuboidRegion;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import java.util.Map.Entry;
import static de.diddiz.LogBlock.Session.getSession;
import static de.diddiz.LogBlock.Session.hasSession;
import static de.diddiz.LogBlock.config.Config.isLogged;
import static de.diddiz.LogBlock.config.Config.toolsByType;
public class ToolListener implements Listener {
private final CommandsHandler handler;
private final LogBlock logblock;
public ToolListener(LogBlock logblock) {
this.logblock = logblock;
handler = logblock.getCommandsHandler();
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getMaterial() != null) {
final Action action = event.getAction();
final Material type = event.getMaterial();
final Tool tool = toolsByType.get(type);
final Player player = event.getPlayer();
if (tool != null && (action == Action.RIGHT_CLICK_BLOCK || action == Action.LEFT_CLICK_BLOCK) && logblock.hasPermission(player, "logblock.tools." + tool.name)) {
final ToolBehavior behavior = action == Action.RIGHT_CLICK_BLOCK ? tool.rightClickBehavior : tool.leftClickBehavior;
final ToolData toolData = getSession(player).toolData.get(tool);
if (behavior != ToolBehavior.NONE && toolData.enabled) {
if (!isLogged(player.getWorld())) {
player.sendMessage(ChatColor.RED + "This world is not currently logged.");
event.setCancelled(true);
return;
}
final Block block = event.getClickedBlock();
final QueryParams params = toolData.params.clone();
params.loc = null;
params.sel = null;
if (behavior == ToolBehavior.BLOCK) {
params.setLocation(block.getRelative(event.getBlockFace()).getLocation());
} else if (tool.params.radius != 0) {
params.setLocation(block.getLocation());
} else {
Block otherHalfChest = BukkitUtils.getConnectedChest(block);
if (otherHalfChest == null) {
params.setLocation(block.getLocation());
} else {
params.setSelection(CuboidRegion.fromCorners(block.getLocation().getWorld(), block.getLocation(), otherHalfChest.getLocation()));
}
}
try {
params.validate();
if (this.callToolUseEvent(new ToolUseEvent(player, tool, behavior, params))) {
return;
}
if (toolData.mode == ToolMode.ROLLBACK) {
handler.new CommandRollback(player, params, true);
} else if (toolData.mode == ToolMode.REDO) {
handler.new CommandRedo(player, params, true);
} else if (toolData.mode == ToolMode.CLEARLOG) {
handler.new CommandClearLog(player, params, true);
} else if (toolData.mode == ToolMode.WRITELOGFILE) {
handler.new CommandWriteLogFile(player, params, true);
} else {
handler.new CommandLookup(player, params, true);
}
} catch (final Exception ex) {
player.sendMessage(ChatColor.RED + ex.getMessage());
}
event.setCancelled(true);
}
}
}
}
private boolean callToolUseEvent(ToolUseEvent event) {
this.logblock.getServer().getPluginManager().callEvent(event);
return event.isCancelled();
}
@EventHandler
public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
final Player player = event.getPlayer();
if (hasSession(player)) {
final Session session = getSession(player);
for (final Entry<Tool, ToolData> entry : session.toolData.entrySet()) {
final Tool tool = entry.getKey();
final ToolData toolData = entry.getValue();
if (toolData.enabled && !logblock.hasPermission(player, "logblock.tools." + tool.name)) {
toolData.enabled = false;
if (tool.removeOnDisable && logblock.hasPermission(player, "logblock.spawnTools")) {
player.getInventory().removeItem(new ItemStack(tool.item, 1));
}
player.sendMessage(ChatColor.GREEN + "Tool disabled.");
}
}
}
}
@EventHandler
public void onPlayerDropItem(PlayerDropItemEvent event) {
final Player player = event.getPlayer();
if (hasSession(player)) {
final Session session = getSession(player);
for (final Entry<Tool, ToolData> entry : session.toolData.entrySet()) {
final Tool tool = entry.getKey();
final ToolData toolData = entry.getValue();
final Material item = event.getItemDrop().getItemStack().getType();
if (item == tool.item && toolData.enabled) {
if (tool.dropToDisable) {
toolData.enabled = false;
ItemStack stack = event.getItemDrop().getItemStack();
if (tool.removeOnDisable && logblock.hasPermission(player, "logblock.spawnTools")) {
if (stack.isSimilar(new ItemStack(item))) {
if (stack.getAmount() > 1) {
stack.setAmount(stack.getAmount() - 1);
event.getItemDrop().setItemStack(stack);
} else {
event.getItemDrop().remove();
}
}
}
if (BukkitUtils.hasInventoryStorageSpaceFor(player.getInventory(), stack)) {
event.setCancelled(true);
}
player.sendMessage(ChatColor.GREEN + "Tool disabled.");
} else if (!tool.canDrop) {
player.sendMessage(ChatColor.RED + "You cannot drop this tool.");
event.setCancelled(true);
}
}
}
}
}
}

48
src/main/java/de/diddiz/LogBlock/listeners/WitherLogging.java
View File

@ -1,24 +1,24 @@
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.entity.Wither;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class WitherLogging extends LoggingListener {
public WitherLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityChangeBlock(EntityChangeBlockEvent event) {
if (event.getEntity() instanceof Wither && isLogging(event.getBlock().getWorld(), Logging.WITHER)) {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getEntity()), event.getBlock().getState(), event.getBlockData()); // Wither walked through a block.
}
}
}
package de.diddiz.LogBlock.listeners;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import org.bukkit.entity.Wither;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import static de.diddiz.LogBlock.config.Config.isLogging;
public class WitherLogging extends LoggingListener {
public WitherLogging(LogBlock lb) {
super(lb);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityChangeBlock(EntityChangeBlockEvent event) {
if (event.getEntity() instanceof Wither && isLogging(event.getBlock().getWorld(), Logging.WITHER)) {
consumer.queueBlockReplace(Actor.actorFromEntity(event.getEntity()), event.getBlock().getState(), event.getBlockData()); // Wither walked through a block.
}
}
}

27
src/main/java/de/diddiz/LogBlock/util/ReflectionUtil.java
View File

@ -1,27 +0,0 @@
package de.diddiz.LogBlock.util;
import org.bukkit.Bukkit;
public class ReflectionUtil {
private static String versionString;
public static String getVersion() {
if (versionString == null) {
String name = Bukkit.getServer().getClass().getPackage().getName();
versionString = name.substring(name.lastIndexOf('.') + 1);
}
return versionString;
}
public static Class<?> getMinecraftClass(String minecraftClassName) throws ClassNotFoundException {
String clazzName = "net.minecraft." + minecraftClassName;
return Class.forName(clazzName);
}
public static Class<?> getCraftBukkitClass(String craftBukkitClassName) throws ClassNotFoundException {
String clazzName = "org.bukkit.craftbukkit." + getVersion() + "." + craftBukkitClassName;
return Class.forName(clazzName);
}
}

2
src/main/java/de/diddiz/LogBlock/util/ActionColor.java → src/main/java/de/diddiz/util/ActionColor.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
import net.md_5.bungee.api.ChatColor;

2125
src/main/java/de/diddiz/LogBlock/util/BukkitUtils.java → src/main/java/de/diddiz/util/BukkitUtils.java
View File

File diff suppressed because it is too large Load Diff

848
src/main/java/de/diddiz/LogBlock/util/ComparableVersion.java → src/main/java/de/diddiz/util/ComparableVersion.java
View File

@ -1,424 +1,424 @@
package de.diddiz.LogBlock.util;
// Taken from maven-artifact at
// http://grepcode.com/file_/repo1.maven.org/maven2/org.apache.maven/maven-artifact/3.2.3/org/apache/maven/artifact/versioning/ComparableVersion.java/?v=source
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Properties;
import java.util.Stack;
/**
* Generic implementation of version comparison.
*
* <p>Features:
* <ul>
* <li>mixing of '<code>-</code>' (dash) and '<code>.</code>' (dot) separators,</li>
* <li>transition between characters and digits also constitutes a separator:
* <code>1.0alpha1 =&gt; [1, 0, alpha, 1]</code></li>
* <li>unlimited number of version components,</li>
* <li>version components in the text can be digits or strings,</li>
* <li>strings are checked for well-known qualifiers and the qualifier ordering is used for version ordering.
* Well-known qualifiers (case insensitive) are:<ul>
* <li><code>alpha</code> or <code>a</code></li>
* <li><code>beta</code> or <code>b</code></li>
* <li><code>milestone</code> or <code>m</code></li>
* <li><code>rc</code> or <code>cr</code></li>
* <li><code>snapshot</code></li>
* <li><code>(the empty string)</code> or <code>ga</code> or <code>final</code></li>
* <li><code>sp</code></li>
* </ul>
* Unknown qualifiers are considered after known qualifiers, with lexical order (always case insensitive),
* </li>
* <li>a dash usually precedes a qualifier, and is always less important than something preceded with a dot.</li>
* </ul></p>
*
* @see <a href="https://cwiki.apache.org/confluence/display/MAVENOLD/Versioning">"Versioning" on Maven Wiki</a>
* @author <a href="mailto:kenney@apache.org">Kenney Westerhof</a>
* @author <a href="mailto:hboutemy@apache.org">Hervé Boutemy</a>
*/
public class ComparableVersion implements Comparable<ComparableVersion> {
private String value;
private String canonical;
private ListItem items;
private interface Item {
int INTEGER_ITEM = 0;
int STRING_ITEM = 1;
int LIST_ITEM = 2;
int compareTo(Item item);
int getType();
boolean isNull();
}
/**
* Represents a numeric item in the version item list.
*/
private static class IntegerItem implements Item {
private static final BigInteger BIG_INTEGER_ZERO = new BigInteger("0");
private final BigInteger value;
public static final IntegerItem ZERO = new IntegerItem();
private IntegerItem() {
this.value = BIG_INTEGER_ZERO;
}
public IntegerItem(String str) {
this.value = new BigInteger(str);
}
@Override
public int getType() {
return INTEGER_ITEM;
}
@Override
public boolean isNull() {
return BIG_INTEGER_ZERO.equals(value);
}
@Override
public int compareTo(Item item) {
if (item == null) {
return BIG_INTEGER_ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
}
switch (item.getType()) {
case INTEGER_ITEM:
return value.compareTo(((IntegerItem) item).value);
case STRING_ITEM:
return 1; // 1.1 > 1-sp
case LIST_ITEM:
return 1; // 1.1 > 1-1
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
return value.toString();
}
}
/**
* Represents a string in the version item list, usually a qualifier.
*/
private static class StringItem implements Item {
private static final String[] QUALIFIERS = { "alpha", "beta", "milestone", "rc", "snapshot", "", "sp" };
private static final List<String> _QUALIFIERS = Arrays.asList(QUALIFIERS);
private static final Properties ALIASES = new Properties();
static {
ALIASES.put("ga", "");
ALIASES.put("final", "");
ALIASES.put("cr", "rc");
}
/**
* A comparable value for the empty-string qualifier. This one is used to determine if a given qualifier makes
* the version older than one without a qualifier, or more recent.
*/
private static final String RELEASE_VERSION_INDEX = String.valueOf(_QUALIFIERS.indexOf(""));
private String value;
public StringItem(String value, boolean followedByDigit) {
if (followedByDigit && value.length() == 1) {
// a1 = alpha-1, b1 = beta-1, m1 = milestone-1
switch (value.charAt(0)) {
case 'a':
value = "alpha";
break;
case 'b':
value = "beta";
break;
case 'm':
value = "milestone";
break;
}
}
this.value = ALIASES.getProperty(value, value);
}
@Override
public int getType() {
return STRING_ITEM;
}
@Override
public boolean isNull() {
return (comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX) == 0);
}
/**
* Returns a comparable value for a qualifier.
*
* This method takes into account the ordering of known qualifiers then unknown qualifiers with lexical ordering.
*
* just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for -1
* or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first character,
* so this is still fast. If more characters are needed then it requires a lexical sort anyway.
*
* @param qualifier
* @return an equivalent value that can be used with lexical comparison
*/
public static String comparableQualifier(String qualifier) {
int i = _QUALIFIERS.indexOf(qualifier);
return i == -1 ? (_QUALIFIERS.size() + "-" + qualifier) : String.valueOf(i);
}
@Override
public int compareTo(Item item) {
if (item == null) {
// 1-rc < 1, 1-ga > 1
return comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX);
}
switch (item.getType()) {
case INTEGER_ITEM:
return -1; // 1.any < 1.1 ?
case STRING_ITEM:
return comparableQualifier(value).compareTo(comparableQualifier(((StringItem) item).value));
case LIST_ITEM:
return -1; // 1.any < 1-1
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
return value;
}
}
/**
* Represents a version list item. This class is used both for the global item list and for sub-lists (which start
* with '-(number)' in the version specification).
*/
private static class ListItem extends ArrayList<Item> implements Item {
private static final long serialVersionUID = 5914575811857700009L;
@Override
public int getType() {
return LIST_ITEM;
}
@Override
public boolean isNull() {
return (size() == 0);
}
void normalize() {
for (ListIterator<Item> iterator = listIterator(size()); iterator.hasPrevious();) {
Item item = iterator.previous();
if (item.isNull()) {
iterator.remove(); // remove null trailing items: 0, "", empty list
} else {
break;
}
}
}
@Override
public int compareTo(Item item) {
if (item == null) {
if (size() == 0) {
return 0; // 1-0 = 1- (normalize) = 1
}
Item first = get(0);
return first.compareTo(null);
}
switch (item.getType()) {
case INTEGER_ITEM:
return -1; // 1-1 < 1.0.x
case STRING_ITEM:
return 1; // 1-1 > 1-sp
case LIST_ITEM:
Iterator<Item> left = iterator();
Iterator<Item> right = ((ListItem) item).iterator();
while (left.hasNext() || right.hasNext()) {
Item l = left.hasNext() ? left.next() : null;
Item r = right.hasNext() ? right.next() : null;
// if this is shorter, then invert the compare and mul with -1
int result = l == null ? (r == null ? 0 : -1 * r.compareTo(l)) : l.compareTo(r);
if (result != 0) {
return result;
}
}
return 0;
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
StringBuilder buffer = new StringBuilder("(");
for (Iterator<Item> iter = iterator(); iter.hasNext();) {
buffer.append(iter.next());
if (iter.hasNext()) {
buffer.append(',');
}
}
buffer.append(')');
return buffer.toString();
}
}
public ComparableVersion(String version) {
parseVersion(version);
}
public final void parseVersion(String version) {
this.value = version;
items = new ListItem();
version = version.toLowerCase(Locale.ENGLISH);
ListItem list = items;
Stack<Item> stack = new Stack<>();
stack.push(list);
boolean isDigit = false;
int startIndex = 0;
for (int i = 0; i < version.length(); i++) {
char c = version.charAt(i);
if (c == '.') {
if (i == startIndex) {
list.add(IntegerItem.ZERO);
} else {
list.add(parseItem(isDigit, version.substring(startIndex, i)));
}
startIndex = i + 1;
} else if (c == '-') {
if (i == startIndex) {
list.add(IntegerItem.ZERO);
} else {
list.add(parseItem(isDigit, version.substring(startIndex, i)));
}
startIndex = i + 1;
if (isDigit) {
list.normalize(); // 1.0-* = 1-*
if ((i + 1 < version.length()) && Character.isDigit(version.charAt(i + 1))) {
// new ListItem only if previous were digits and new char is a digit,
// ie need to differentiate only 1.1 from 1-1
list.add(list = new ListItem());
stack.push(list);
}
}
} else if (Character.isDigit(c)) {
if (!isDigit && i > startIndex) {
list.add(new StringItem(version.substring(startIndex, i), true));
startIndex = i;
}
isDigit = true;
} else {
if (isDigit && i > startIndex) {
list.add(parseItem(true, version.substring(startIndex, i)));
startIndex = i;
}
isDigit = false;
}
}
if (version.length() > startIndex) {
list.add(parseItem(isDigit, version.substring(startIndex)));
}
while (!stack.isEmpty()) {
list = (ListItem) stack.pop();
list.normalize();
}
canonical = items.toString();
}
private static Item parseItem(boolean isDigit, String buf) {
return isDigit ? new IntegerItem(buf) : new StringItem(buf, false);
}
@Override
public int compareTo(ComparableVersion o) {
return items.compareTo(o.items);
}
public int compareTo(String version) {
return compareTo(new ComparableVersion(version));
}
@Override
public String toString() {
return value;
}
public String toCanonicalString() {
return canonical;
}
@Override
public boolean equals(Object o) {
return (o instanceof ComparableVersion) && canonical.equals(((ComparableVersion) o).canonical);
}
@Override
public int hashCode() {
return canonical.hashCode();
}
}
package de.diddiz.util;
// Taken from maven-artifact at
// http://grepcode.com/file_/repo1.maven.org/maven2/org.apache.maven/maven-artifact/3.2.3/org/apache/maven/artifact/versioning/ComparableVersion.java/?v=source
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Properties;
import java.util.Stack;
/**
* Generic implementation of version comparison.
*
* <p>Features:
* <ul>
* <li>mixing of '<code>-</code>' (dash) and '<code>.</code>' (dot) separators,</li>
* <li>transition between characters and digits also constitutes a separator:
* <code>1.0alpha1 =&gt; [1, 0, alpha, 1]</code></li>
* <li>unlimited number of version components,</li>
* <li>version components in the text can be digits or strings,</li>
* <li>strings are checked for well-known qualifiers and the qualifier ordering is used for version ordering.
* Well-known qualifiers (case insensitive) are:<ul>
* <li><code>alpha</code> or <code>a</code></li>
* <li><code>beta</code> or <code>b</code></li>
* <li><code>milestone</code> or <code>m</code></li>
* <li><code>rc</code> or <code>cr</code></li>
* <li><code>snapshot</code></li>
* <li><code>(the empty string)</code> or <code>ga</code> or <code>final</code></li>
* <li><code>sp</code></li>
* </ul>
* Unknown qualifiers are considered after known qualifiers, with lexical order (always case insensitive),
* </li>
* <li>a dash usually precedes a qualifier, and is always less important than something preceded with a dot.</li>
* </ul></p>
*
* @see <a href="https://cwiki.apache.org/confluence/display/MAVENOLD/Versioning">"Versioning" on Maven Wiki</a>
* @author <a href="mailto:kenney@apache.org">Kenney Westerhof</a>
* @author <a href="mailto:hboutemy@apache.org">Hervé Boutemy</a>
*/
public class ComparableVersion implements Comparable<ComparableVersion> {
private String value;
private String canonical;
private ListItem items;
private interface Item {
int INTEGER_ITEM = 0;
int STRING_ITEM = 1;
int LIST_ITEM = 2;
int compareTo(Item item);
int getType();
boolean isNull();
}
/**
* Represents a numeric item in the version item list.
*/
private static class IntegerItem implements Item {
private static final BigInteger BIG_INTEGER_ZERO = new BigInteger("0");
private final BigInteger value;
public static final IntegerItem ZERO = new IntegerItem();
private IntegerItem() {
this.value = BIG_INTEGER_ZERO;
}
public IntegerItem(String str) {
this.value = new BigInteger(str);
}
@Override
public int getType() {
return INTEGER_ITEM;
}
@Override
public boolean isNull() {
return BIG_INTEGER_ZERO.equals(value);
}
@Override
public int compareTo(Item item) {
if (item == null) {
return BIG_INTEGER_ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
}
switch (item.getType()) {
case INTEGER_ITEM:
return value.compareTo(((IntegerItem) item).value);
case STRING_ITEM:
return 1; // 1.1 > 1-sp
case LIST_ITEM:
return 1; // 1.1 > 1-1
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
return value.toString();
}
}
/**
* Represents a string in the version item list, usually a qualifier.
*/
private static class StringItem implements Item {
private static final String[] QUALIFIERS = { "alpha", "beta", "milestone", "rc", "snapshot", "", "sp" };
private static final List<String> _QUALIFIERS = Arrays.asList(QUALIFIERS);
private static final Properties ALIASES = new Properties();
static {
ALIASES.put("ga", "");
ALIASES.put("final", "");
ALIASES.put("cr", "rc");
}
/**
* A comparable value for the empty-string qualifier. This one is used to determine if a given qualifier makes
* the version older than one without a qualifier, or more recent.
*/
private static final String RELEASE_VERSION_INDEX = String.valueOf(_QUALIFIERS.indexOf(""));
private String value;
public StringItem(String value, boolean followedByDigit) {
if (followedByDigit && value.length() == 1) {
// a1 = alpha-1, b1 = beta-1, m1 = milestone-1
switch (value.charAt(0)) {
case 'a':
value = "alpha";
break;
case 'b':
value = "beta";
break;
case 'm':
value = "milestone";
break;
}
}
this.value = ALIASES.getProperty(value, value);
}
@Override
public int getType() {
return STRING_ITEM;
}
@Override
public boolean isNull() {
return (comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX) == 0);
}
/**
* Returns a comparable value for a qualifier.
*
* This method takes into account the ordering of known qualifiers then unknown qualifiers with lexical ordering.
*
* just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for -1
* or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first character,
* so this is still fast. If more characters are needed then it requires a lexical sort anyway.
*
* @param qualifier
* @return an equivalent value that can be used with lexical comparison
*/
public static String comparableQualifier(String qualifier) {
int i = _QUALIFIERS.indexOf(qualifier);
return i == -1 ? (_QUALIFIERS.size() + "-" + qualifier) : String.valueOf(i);
}
@Override
public int compareTo(Item item) {
if (item == null) {
// 1-rc < 1, 1-ga > 1
return comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX);
}
switch (item.getType()) {
case INTEGER_ITEM:
return -1; // 1.any < 1.1 ?
case STRING_ITEM:
return comparableQualifier(value).compareTo(comparableQualifier(((StringItem) item).value));
case LIST_ITEM:
return -1; // 1.any < 1-1
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
return value;
}
}
/**
* Represents a version list item. This class is used both for the global item list and for sub-lists (which start
* with '-(number)' in the version specification).
*/
private static class ListItem extends ArrayList<Item> implements Item {
private static final long serialVersionUID = 5914575811857700009L;
@Override
public int getType() {
return LIST_ITEM;
}
@Override
public boolean isNull() {
return (size() == 0);
}
void normalize() {
for (ListIterator<Item> iterator = listIterator(size()); iterator.hasPrevious();) {
Item item = iterator.previous();
if (item.isNull()) {
iterator.remove(); // remove null trailing items: 0, "", empty list
} else {
break;
}
}
}
@Override
public int compareTo(Item item) {
if (item == null) {
if (size() == 0) {
return 0; // 1-0 = 1- (normalize) = 1
}
Item first = get(0);
return first.compareTo(null);
}
switch (item.getType()) {
case INTEGER_ITEM:
return -1; // 1-1 < 1.0.x
case STRING_ITEM:
return 1; // 1-1 > 1-sp
case LIST_ITEM:
Iterator<Item> left = iterator();
Iterator<Item> right = ((ListItem) item).iterator();
while (left.hasNext() || right.hasNext()) {
Item l = left.hasNext() ? left.next() : null;
Item r = right.hasNext() ? right.next() : null;
// if this is shorter, then invert the compare and mul with -1
int result = l == null ? (r == null ? 0 : -1 * r.compareTo(l)) : l.compareTo(r);
if (result != 0) {
return result;
}
}
return 0;
default:
throw new RuntimeException("invalid item: " + item.getClass());
}
}
@Override
public String toString() {
StringBuilder buffer = new StringBuilder("(");
for (Iterator<Item> iter = iterator(); iter.hasNext();) {
buffer.append(iter.next());
if (iter.hasNext()) {
buffer.append(',');
}
}
buffer.append(')');
return buffer.toString();
}
}
public ComparableVersion(String version) {
parseVersion(version);
}
public final void parseVersion(String version) {
this.value = version;
items = new ListItem();
version = version.toLowerCase(Locale.ENGLISH);
ListItem list = items;
Stack<Item> stack = new Stack<>();
stack.push(list);
boolean isDigit = false;
int startIndex = 0;
for (int i = 0; i < version.length(); i++) {
char c = version.charAt(i);
if (c == '.') {
if (i == startIndex) {
list.add(IntegerItem.ZERO);
} else {
list.add(parseItem(isDigit, version.substring(startIndex, i)));
}
startIndex = i + 1;
} else if (c == '-') {
if (i == startIndex) {
list.add(IntegerItem.ZERO);
} else {
list.add(parseItem(isDigit, version.substring(startIndex, i)));
}
startIndex = i + 1;
if (isDigit) {
list.normalize(); // 1.0-* = 1-*
if ((i + 1 < version.length()) && Character.isDigit(version.charAt(i + 1))) {
// new ListItem only if previous were digits and new char is a digit,
// ie need to differentiate only 1.1 from 1-1
list.add(list = new ListItem());
stack.push(list);
}
}
} else if (Character.isDigit(c)) {
if (!isDigit && i > startIndex) {
list.add(new StringItem(version.substring(startIndex, i), true));
startIndex = i;
}
isDigit = true;
} else {
if (isDigit && i > startIndex) {
list.add(parseItem(true, version.substring(startIndex, i)));
startIndex = i;
}
isDigit = false;
}
}
if (version.length() > startIndex) {
list.add(parseItem(isDigit, version.substring(startIndex)));
}
while (!stack.isEmpty()) {
list = (ListItem) stack.pop();
list.normalize();
}
canonical = items.toString();
}
private static Item parseItem(boolean isDigit, String buf) {
return isDigit ? new IntegerItem(buf) : new StringItem(buf, false);
}
@Override
public int compareTo(ComparableVersion o) {
return items.compareTo(o.items);
}
public int compareTo(String version) {
return compareTo(new ComparableVersion(version));
}
@Override
public String toString() {
return value;
}
public String toCanonicalString() {
return canonical;
}
@Override
public boolean equals(Object o) {
return (o instanceof ComparableVersion) && canonical.equals(((ComparableVersion) o).canonical);
}
@Override
public int hashCode() {
return canonical.hashCode();
}
}

2
src/main/java/de/diddiz/LogBlock/util/CuboidRegion.java → src/main/java/de/diddiz/util/CuboidRegion.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
import org.bukkit.Location;
import org.bukkit.World;

86
src/main/java/de/diddiz/LogBlock/util/LoggingUtil.java → src/main/java/de/diddiz/util/LoggingUtil.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
import de.diddiz.LogBlock.Actor;
import de.diddiz.LogBlock.Consumer;
@ -14,8 +14,6 @@ import org.bukkit.block.data.Directional;
import org.bukkit.block.data.type.Bell;
import org.bukkit.block.data.type.Bell.Attachment;
import org.bukkit.block.data.type.Lantern;
import org.bukkit.block.data.type.PointedDripstone;
import org.bukkit.block.data.type.PointedDripstone.Thickness;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.TNTPrimed;
@ -54,18 +52,18 @@ public class LoggingUtil {
int initialy = loc.getBlockY();
int y = initialy;
int z = loc.getBlockZ();
while (y > loc.getWorld().getMinHeight() && BukkitUtils.canFallIn(loc.getWorld(), x, (y - 1), z)) {
while (y > 0 && BukkitUtils.canFallIn(loc.getWorld(), x, (y - 1), z)) {
y--;
}
if (initialy != y && !BukkitUtils.isEmpty(replaced.getType())) {
// this is not the final location but the block got removed (vines etc)
consumer.queueBlockBreak(actor, replaced);
}
// If y is minHeight then the block fell out of the world :(
if (y > loc.getWorld().getMinHeight()) {
// If y is 0 then the block fell out of the world :(
if (y != 0) {
// Run this check to avoid false positives
Location finalLoc = new Location(loc.getWorld(), x, y, z);
if (y == initialy || !BukkitUtils.isFallingEntityKiller(finalLoc.getBlock().getType())) {
if (y == initialy || !BukkitUtils.getFallingEntityKillers().contains(finalLoc.getBlock().getType())) {
if (BukkitUtils.isEmpty(finalLoc.getBlock().getType())) {
consumer.queueBlockPlace(actor, finalLoc, placed.getBlockData());
} else {
@ -96,14 +94,14 @@ public class LoggingUtil {
int x = loc.getBlockX();
int y = loc.getBlockY();
int z = loc.getBlockZ();
while (y > loc.getWorld().getMinHeight() && BukkitUtils.canFallIn(loc.getWorld(), x, (y - 1), z)) {
while (y > 0 && BukkitUtils.canFallIn(loc.getWorld(), x, (y - 1), z)) {
y--;
}
// If y is minHeight then the sand block fell out of the world :(
if (y > loc.getWorld().getMinHeight()) {
// If y is 0 then the sand block fell out of the world :(
if (y != 0) {
Location finalLoc = new Location(loc.getWorld(), x, y, z);
// Run this check to avoid false positives
if (!BukkitUtils.isFallingEntityKiller(finalLoc.getBlock().getType())) {
if (!BukkitUtils.getFallingEntityKillers().contains(finalLoc.getBlock().getType())) {
finalLoc.add(0, up, 0); // Add this here after checking for block breakers
if (BukkitUtils.isEmpty(finalLoc.getBlock().getType())) {
consumer.queueBlockPlace(actor, finalLoc, checkBlock.getBlockData());
@ -146,16 +144,10 @@ public class LoggingUtil {
consumer.queueBlockReplace(actor, above.getState(), Material.WEEPING_VINES.createBlockData());
}
}
if (replacedType == Material.CAVE_VINES || replacedType == Material.CAVE_VINES_PLANT) {
Block above = origin.getRelative(BlockFace.UP);
if (above.getType() == Material.CAVE_VINES_PLANT) {
consumer.queueBlockReplace(actor, above.getState(), Material.CAVE_VINES.createBlockData());
}
}
Block checkBlock = origin.getRelative(BlockFace.UP);
Material typeAbove = checkBlock.getType();
if (BukkitUtils.isRelativeTopBreakable(typeAbove)) {
if (BukkitUtils.getRelativeTopBreakabls().contains(typeAbove)) {
if (typeAbove == Material.IRON_DOOR || BukkitUtils.isWoodenDoor(typeAbove)) {
Block doorBlock = checkBlock;
// If the doorBlock is the top half a door the player simply punched a door
@ -185,7 +177,7 @@ public class LoggingUtil {
// check next blocks above
checkBlock = checkBlock.getRelative(BlockFace.UP);
typeAbove = checkBlock.getType();
while (BukkitUtils.isRelativeTopBreakable(typeAbove)) {
while (BukkitUtils.getRelativeTopBreakabls().contains(typeAbove)) {
consumer.queueBlockBreak(actor, checkBlock.getState());
checkBlock = checkBlock.getRelative(BlockFace.UP);
typeAbove = checkBlock.getType();
@ -201,24 +193,6 @@ public class LoggingUtil {
if (bell.getAttachment() == Attachment.FLOOR) {
consumer.queueBlockBreak(actor, checkBlock.getState());
}
} else if (typeAbove == Material.POINTED_DRIPSTONE) {
Block dripStoneBlock = checkBlock;
while (true) {
if (dripStoneBlock.getType() != Material.POINTED_DRIPSTONE) {
break;
}
PointedDripstone dripstone = (PointedDripstone) dripStoneBlock.getBlockData();
if (dripstone.getVerticalDirection() != BlockFace.UP) {
if (dripstone.getThickness() == Thickness.TIP_MERGE) {
PointedDripstone newDripstone = (PointedDripstone) dripstone.clone();
newDripstone.setThickness(Thickness.TIP);
consumer.queueBlockReplace(actor, dripStoneBlock.getState(), newDripstone);
}
break;
}
consumer.queueBlockBreak(actor, dripStoneBlock.getState());
dripStoneBlock = dripStoneBlock.getRelative(BlockFace.UP);
}
}
checkBlock = origin.getRelative(BlockFace.DOWN);
@ -228,55 +202,25 @@ public class LoggingUtil {
if (lantern.isHanging()) {
consumer.queueBlockBreak(actor, checkBlock.getState());
}
} else if (BukkitUtils.isHangingSign(typeBelow)) {
consumer.queueBlockBreak(actor, checkBlock.getState());
} else if (typeBelow == Material.BELL) {
Bell bell = (Bell) checkBlock.getBlockData();
if (bell.getAttachment() == Attachment.CEILING) {
consumer.queueBlockBreak(actor, checkBlock.getState());
}
} else if (typeBelow == Material.WEEPING_VINES || typeBelow == Material.WEEPING_VINES_PLANT || typeBelow == Material.CAVE_VINES || typeBelow == Material.CAVE_VINES_PLANT) {
} else if (typeBelow == Material.WEEPING_VINES || typeBelow == Material.WEEPING_VINES_PLANT) {
consumer.queueBlockBreak(actor, checkBlock.getState());
// check next blocks below
// check next blocks above
checkBlock = checkBlock.getRelative(BlockFace.DOWN);
typeBelow = checkBlock.getType();
while (typeBelow == Material.WEEPING_VINES || typeBelow == Material.WEEPING_VINES_PLANT || typeBelow == Material.CAVE_VINES || typeBelow == Material.CAVE_VINES_PLANT) {
while (typeBelow == Material.WEEPING_VINES || typeBelow == Material.WEEPING_VINES_PLANT) {
consumer.queueBlockBreak(actor, checkBlock.getState());
checkBlock = checkBlock.getRelative(BlockFace.DOWN);
typeBelow = checkBlock.getType();
}
} else if ((replacedType == Material.BIG_DRIPLEAF || replacedType == Material.BIG_DRIPLEAF_STEM) && (typeBelow == Material.BIG_DRIPLEAF || typeBelow == Material.BIG_DRIPLEAF_STEM)) {
consumer.queueBlockBreak(actor, checkBlock.getState());
// check next blocks below
checkBlock = checkBlock.getRelative(BlockFace.DOWN);
typeBelow = checkBlock.getType();
while (typeBelow == Material.BIG_DRIPLEAF || typeBelow == Material.BIG_DRIPLEAF_STEM) {
consumer.queueBlockBreak(actor, checkBlock.getState());
checkBlock = checkBlock.getRelative(BlockFace.DOWN);
typeBelow = checkBlock.getType();
}
} else if (typeBelow == Material.POINTED_DRIPSTONE) {
Block dripStoneBlock = checkBlock;
while (true) {
if (dripStoneBlock.getType() != Material.POINTED_DRIPSTONE) {
break;
}
PointedDripstone dripstone = (PointedDripstone) dripStoneBlock.getBlockData();
if (dripstone.getVerticalDirection() != BlockFace.DOWN) {
if (dripstone.getThickness() == Thickness.TIP_MERGE) {
PointedDripstone newDripstone = (PointedDripstone) dripstone.clone();
newDripstone.setThickness(Thickness.TIP);
consumer.queueBlockReplace(actor, dripStoneBlock.getState(), newDripstone);
}
break;
}
consumer.queueBlockBreak(actor, dripStoneBlock.getState());
dripStoneBlock = dripStoneBlock.getRelative(BlockFace.DOWN);
}
}
List<Location> relativeBreakables = BukkitUtils.getBlocksNearby(origin, BukkitUtils.getRelativeBreakables());
if (!relativeBreakables.isEmpty()) {
if (relativeBreakables.size() != 0) {
for (Location location : relativeBreakables) {
Block block = location.getBlock();
BlockData blockData = block.getBlockData();

19
src/main/java/de/diddiz/LogBlock/util/MessagingUtil.java → src/main/java/de/diddiz/util/MessagingUtil.java
View File

@ -1,9 +1,9 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
import static de.diddiz.LogBlock.util.ActionColor.CREATE;
import static de.diddiz.LogBlock.util.ActionColor.DESTROY;
import static de.diddiz.LogBlock.util.TypeColor.DEFAULT;
import static de.diddiz.LogBlock.util.Utils.spaces;
import static de.diddiz.util.ActionColor.CREATE;
import static de.diddiz.util.ActionColor.DESTROY;
import static de.diddiz.util.TypeColor.DEFAULT;
import static de.diddiz.util.Utils.spaces;
import de.diddiz.LogBlock.config.Config;
import net.md_5.bungee.api.ChatColor;
@ -49,15 +49,6 @@ public class MessagingUtil {
return createTextComponentWithColor(stateName, TypeColor.STATE.getColor());
}
public static TextComponent prettyState(BaseComponent stateName) {
TextComponent tc = new TextComponent();
tc.setColor(TypeColor.STATE.getColor());
if (stateName != null) {
tc.addExtra(stateName);
}
return tc;
}
public static TextComponent prettyState(int stateValue) {
return prettyState(Integer.toString(stateValue));
}

102
src/main/java/de/diddiz/LogBlock/util/MySQLConnectionPool.java → src/main/java/de/diddiz/util/MySQLConnectionPool.java
View File

@ -1,51 +1,51 @@
package de.diddiz.LogBlock.util;
import com.zaxxer.hikari.HikariDataSource;
import de.diddiz.LogBlock.config.Config;
import java.io.Closeable;
import java.sql.Connection;
import java.sql.SQLException;
public class MySQLConnectionPool implements Closeable {
private final HikariDataSource ds;
public MySQLConnectionPool(String url, String user, String password, boolean useSSL, boolean requireSSL) {
this.ds = new HikariDataSource();
ds.setJdbcUrl(url);
ds.setUsername(user);
ds.setPassword(password);
ds.setMinimumIdle(2);
ds.setMaximumPoolSize(15);
ds.setPoolName("LogBlock-Connection-Pool");
ds.addDataSourceProperty("useUnicode", "true");
ds.addDataSourceProperty("characterEncoding", "utf-8");
ds.addDataSourceProperty("rewriteBatchedStatements", "true");
ds.addDataSourceProperty("cachePrepStmts", "true");
ds.addDataSourceProperty("prepStmtCacheSize", "250");
ds.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
ds.addDataSourceProperty("useServerPrepStmts", "true");
ds.addDataSourceProperty("useSSL", Boolean.toString(useSSL));
ds.addDataSourceProperty("requireSSL", Boolean.toString(requireSSL));
ds.addDataSourceProperty("verifyServerCertificate", "false");
}
@Override
public void close() {
ds.close();
}
public Connection getConnection() throws SQLException {
Connection connection = ds.getConnection();
if (Config.mb4) {
connection.createStatement().executeUpdate("SET NAMES utf8mb4");
}
return connection;
}
}
package de.diddiz.util;
import com.zaxxer.hikari.HikariDataSource;
import de.diddiz.LogBlock.config.Config;
import java.io.Closeable;
import java.sql.Connection;
import java.sql.SQLException;
public class MySQLConnectionPool implements Closeable {
private final HikariDataSource ds;
public MySQLConnectionPool(String url, String user, String password, boolean useSSL, boolean requireSSL) {
this.ds = new HikariDataSource();
ds.setJdbcUrl(url);
ds.setUsername(user);
ds.setPassword(password);
ds.setMinimumIdle(2);
ds.setMaximumPoolSize(15);
ds.setPoolName("LogBlock-Connection-Pool");
ds.addDataSourceProperty("useUnicode", "true");
ds.addDataSourceProperty("characterEncoding", "utf-8");
ds.addDataSourceProperty("rewriteBatchedStatements", "true");
ds.addDataSourceProperty("cachePrepStmts", "true");
ds.addDataSourceProperty("prepStmtCacheSize", "250");
ds.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
ds.addDataSourceProperty("useServerPrepStmts", "true");
ds.addDataSourceProperty("useSSL", Boolean.toString(useSSL));
ds.addDataSourceProperty("requireSSL", Boolean.toString(requireSSL));
ds.addDataSourceProperty("verifyServerCertificate", "false");
}
@Override
public void close() {
ds.close();
}
public Connection getConnection() throws SQLException {
Connection connection = ds.getConnection();
if (Config.mb4) {
connection.createStatement().executeQuery("SET NAMES utf8mb4");
}
return connection;
}
}

2
src/main/java/de/diddiz/LogBlock/util/SqlUtil.java → src/main/java/de/diddiz/util/SqlUtil.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
public class SqlUtil {
public static String escapeString(String s) {

2
src/main/java/de/diddiz/LogBlock/util/TypeColor.java → src/main/java/de/diddiz/util/TypeColor.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.util;
package de.diddiz.util;
import net.md_5.bungee.api.ChatColor;

122
src/main/java/de/diddiz/LogBlock/util/UUIDFetcher.java → src/main/java/de/diddiz/util/UUIDFetcher.java
View File

@ -1,61 +1,61 @@
package de.diddiz.LogBlock.util;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
// Adapted from https://gist.github.com/evilmidget38/26d70114b834f71fb3b4
public class UUIDFetcher {
private static final String PROFILE_URL = "https://api.mojang.com/profiles/minecraft";
private static final Gson gson = new GsonBuilder().setLenient().create();
public static Map<String, UUID> getUUIDs(List<String> names) throws Exception {
Map<String, UUID> uuidMap = new HashMap<>();
HttpURLConnection connection = createConnection();
String body = gson.toJson(names);
writeBody(connection, body);
JsonArray array = gson.fromJson(new InputStreamReader(connection.getInputStream()), JsonArray.class);
for (JsonElement profile : array) {
JsonObject jsonProfile = (JsonObject) profile;
String id = jsonProfile.get("id").getAsString();
String name = jsonProfile.get("name").getAsString();
UUID uuid = getUUID(id);
uuidMap.put(name, uuid);
}
return uuidMap;
}
private static void writeBody(HttpURLConnection connection, String body) throws Exception {
OutputStream stream = connection.getOutputStream();
stream.write(body.getBytes());
stream.flush();
stream.close();
}
private static HttpURLConnection createConnection() throws Exception {
URL url = new URL(PROFILE_URL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
return connection;
}
private static UUID getUUID(String id) {
return UUID.fromString(id.substring(0, 8) + "-" + id.substring(8, 12) + "-" + id.substring(12, 16) + "-" + id.substring(16, 20) + "-" + id.substring(20, 32));
}
}
package de.diddiz.util;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
// Adapted from https://gist.github.com/evilmidget38/26d70114b834f71fb3b4
public class UUIDFetcher {
private static final String PROFILE_URL = "https://api.mojang.com/profiles/minecraft";
private static final Gson gson = new GsonBuilder().setLenient().create();
public static Map<String, UUID> getUUIDs(List<String> names) throws Exception {
Map<String, UUID> uuidMap = new HashMap<>();
HttpURLConnection connection = createConnection();
String body = gson.toJson(names);
writeBody(connection, body);
JsonArray array = gson.fromJson(new InputStreamReader(connection.getInputStream()), JsonArray.class);
for (JsonElement profile : array) {
JsonObject jsonProfile = (JsonObject) profile;
String id = jsonProfile.get("id").getAsString();
String name = jsonProfile.get("name").getAsString();
UUID uuid = getUUID(id);
uuidMap.put(name, uuid);
}
return uuidMap;
}
private static void writeBody(HttpURLConnection connection, String body) throws Exception {
OutputStream stream = connection.getOutputStream();
stream.write(body.getBytes());
stream.flush();
stream.close();
}
private static HttpURLConnection createConnection() throws Exception {
URL url = new URL(PROFILE_URL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
return connection;
}
private static UUID getUUID(String id) {
return UUID.fromString(id.substring(0, 8) + "-" + id.substring(8, 12) + "-" + id.substring(12, 16) + "-" + id.substring(16, 20) + "-" + id.substring(20, 32));
}
}

585
src/main/java/de/diddiz/LogBlock/util/Utils.java → src/main/java/de/diddiz/util/Utils.java
View File

@ -1,298 +1,287 @@
package de.diddiz.LogBlock.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipException;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.inventory.ItemStack;
import de.diddiz.LogBlock.LogBlock;
public class Utils {
public static String newline = System.getProperty("line.separator");
public static boolean isInt(String str) {
try {
Integer.parseInt(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static boolean isShort(String str) {
try {
Short.parseShort(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static boolean isByte(String str) {
try {
Byte.parseByte(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static String listing(String[] entries, String delimiter, String finalDelimiter) {
final int len = entries.length;
if (len == 0) {
return "";
}
if (len == 1) {
return entries[0];
}
final StringBuilder builder = new StringBuilder(entries[0]);
for (int i = 1; i < len - 1; i++) {
builder.append(delimiter).append(entries[i]);
}
builder.append(finalDelimiter).append(entries[len - 1]);
return builder.toString();
}
public static String listing(List<?> entries, String delimiter, String finalDelimiter) {
final int len = entries.size();
if (len == 0) {
return "";
}
if (len == 1) {
return entries.get(0).toString();
}
final StringBuilder builder = new StringBuilder(entries.get(0).toString());
for (int i = 1; i < len - 1; i++) {
builder.append(delimiter).append(entries.get(i).toString());
}
builder.append(finalDelimiter).append(entries.get(len - 1).toString());
return builder.toString();
}
public static int parseTimeSpec(String[] spec) {
if (spec == null || spec.length < 1 || spec.length > 2) {
return -1;
}
if (spec.length == 1 && isInt(spec[0])) {
return Integer.valueOf(spec[0]);
}
if (!spec[0].contains(":") && !spec[0].contains(".")) {
if (spec.length == 2) {
if (!isInt(spec[0])) {
return -1;
}
int min = Integer.parseInt(spec[0]);
if (spec[1].startsWith("h")) {
min *= 60;
} else if (spec[1].startsWith("d")) {
min *= 1440;
}
return min;
} else if (spec.length == 1) {
int days = 0, hours = 0, minutes = 0;
int lastIndex = 0, currIndex = 1;
while (currIndex <= spec[0].length()) {
while (currIndex <= spec[0].length() && isInt(spec[0].substring(lastIndex, currIndex))) {
currIndex++;
}
if (currIndex - 1 != lastIndex) {
if (currIndex > spec[0].length()) {
return -1;
}
final String param = spec[0].substring(currIndex - 1, currIndex).toLowerCase();
if (param.equals("d")) {
days = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
} else if (param.equals("h")) {
hours = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
} else if (param.equals("m")) {
minutes = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
}
}
lastIndex = currIndex;
currIndex++;
}
if (days == 0 && hours == 0 && minutes == 0) {
return -1;
}
return minutes + hours * 60 + days * 1440;
} else {
return -1;
}
}
final String timestamp;
if (spec.length == 1) {
if (spec[0].contains(":")) {
timestamp = new SimpleDateFormat("dd.MM.yyyy").format(System.currentTimeMillis()) + " " + spec[0];
} else {
timestamp = spec[0] + " 00:00:00";
}
} else {
timestamp = spec[0] + " " + spec[1];
}
try {
return (int) ((System.currentTimeMillis() - new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").parse(timestamp).getTime()) / 60000);
} catch (final ParseException ex) {
return -1;
}
}
public static String spaces(int count) {
final StringBuilder filled = new StringBuilder(count);
for (int i = 0; i < count; i++) {
filled.append(' ');
}
return filled.toString();
}
public static String join(String[] s, String delimiter) {
if (s == null || s.length == 0) {
return "";
}
final int len = s.length;
final StringBuilder builder = new StringBuilder(s[0]);
for (int i = 1; i < len; i++) {
builder.append(delimiter).append(s[i]);
}
return builder.toString();
}
/**
* Converts a list of arguments e.g ['lb', 'clearlog', 'world', '"my', 'world', 'of', 'swag"']
* into a list of arguments with any text encapsulated by quotes treated as one word
* For this particular example: ['lb', 'clearlog', 'world', '"my world of swag"']
*
* @param args The list of arguments
* @return A new list with the quoted arguments parsed to single values
*/
public static List<String> parseQuotes(List<String> args) {
List<String> newArguments = new ArrayList<>();
String subjectString = join(args.toArray(new String[args.size()]), " ");
Pattern regex = Pattern.compile("[^\\s\"']+|\"[^\"]*\"|'[^']*'");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
newArguments.add(regexMatcher.group());
}
return newArguments;
}
public static class ExtensionFilenameFilter implements FilenameFilter {
private final String ext;
public ExtensionFilenameFilter(String ext) {
this.ext = "." + ext;
}
@Override
public boolean accept(File dir, String name) {
return name.toLowerCase().endsWith(ext);
}
}
private final static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String mysqlEscapeBytes(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2 + 2];
hexChars[0] = '0';
hexChars[1] = 'x';
for (int j = 0; j < bytes.length; j++) {
int v = bytes[j] & 0xFF;
hexChars[j * 2 + 2] = hexArray[v >>> 4];
hexChars[j * 2 + 3] = hexArray[v & 0x0F];
}
return new String(hexChars);
}
public static String mysqlPrepareBytesForInsertAllowNull(byte[] bytes) {
if (bytes == null) {
return "null";
}
return "'" + mysqlEscapeBytes(bytes) + "'";
}
public static String mysqlTextEscape(String untrusted) {
return untrusted.replace("\\", "\\\\").replace("'", "\\'");
}
public static ItemStack loadItemStack(byte[] data) {
if (data == null || data.length == 0) {
return null;
}
YamlConfiguration conf = deserializeYamlConfiguration(data);
return conf == null ? null : conf.getItemStack("stack");
}
public static byte[] saveItemStack(ItemStack stack) {
if (stack == null || BukkitUtils.isEmpty(stack.getType())) {
return null;
}
YamlConfiguration conf = new YamlConfiguration();
conf.set("stack", stack);
return serializeYamlConfiguration(conf);
}
public static YamlConfiguration deserializeYamlConfiguration(byte[] data) {
if (data == null || data.length == 0) {
return null;
}
YamlConfiguration conf = new YamlConfiguration();
try {
InputStreamReader reader = new InputStreamReader(new GZIPInputStream(new ByteArrayInputStream(data)), "UTF-8");
conf.load(reader);
reader.close();
return conf;
} catch (ZipException | InvalidConfigurationException e) {
LogBlock.getInstance().getLogger().warning("Could not deserialize YamlConfiguration: " + e.getMessage());
return conf;
} catch (IOException e) {
throw new RuntimeException("IOException should be impossible for ByteArrayInputStream", e);
}
}
public static byte[] serializeYamlConfiguration(YamlConfiguration conf) {
if (conf == null || conf.getKeys(false).isEmpty()) {
return null;
}
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(new GZIPOutputStream(baos), "UTF-8");
writer.write(conf.saveToString());
writer.close();
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException("IOException should be impossible for ByteArrayOutputStream", e);
}
}
public static String serializeForSQL(YamlConfiguration conf) {
return mysqlPrepareBytesForInsertAllowNull(serializeYamlConfiguration(conf));
}
public static double warpDegrees(double degrees) {
double d = degrees % 360.0;
if (d >= 180.0) {
d -= 360.0;
}
if (d < -180.0) {
d += 360.0;
}
return d;
}
}
package de.diddiz.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipException;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.inventory.ItemStack;
import de.diddiz.LogBlock.LogBlock;
public class Utils {
public static String newline = System.getProperty("line.separator");
public static boolean isInt(String str) {
try {
Integer.parseInt(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static boolean isShort(String str) {
try {
Short.parseShort(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static boolean isByte(String str) {
try {
Byte.parseByte(str);
return true;
} catch (final NumberFormatException ex) {
}
return false;
}
public static String listing(String[] entries, String delimiter, String finalDelimiter) {
final int len = entries.length;
if (len == 0) {
return "";
}
if (len == 1) {
return entries[0];
}
final StringBuilder builder = new StringBuilder(entries[0]);
for (int i = 1; i < len - 1; i++) {
builder.append(delimiter).append(entries[i]);
}
builder.append(finalDelimiter).append(entries[len - 1]);
return builder.toString();
}
public static String listing(List<?> entries, String delimiter, String finalDelimiter) {
final int len = entries.size();
if (len == 0) {
return "";
}
if (len == 1) {
return entries.get(0).toString();
}
final StringBuilder builder = new StringBuilder(entries.get(0).toString());
for (int i = 1; i < len - 1; i++) {
builder.append(delimiter).append(entries.get(i).toString());
}
builder.append(finalDelimiter).append(entries.get(len - 1).toString());
return builder.toString();
}
public static int parseTimeSpec(String[] spec) {
if (spec == null || spec.length < 1 || spec.length > 2) {
return -1;
}
if (spec.length == 1 && isInt(spec[0])) {
return Integer.valueOf(spec[0]);
}
if (!spec[0].contains(":") && !spec[0].contains(".")) {
if (spec.length == 2) {
if (!isInt(spec[0])) {
return -1;
}
int min = Integer.parseInt(spec[0]);
if (spec[1].startsWith("h")) {
min *= 60;
} else if (spec[1].startsWith("d")) {
min *= 1440;
}
return min;
} else if (spec.length == 1) {
int days = 0, hours = 0, minutes = 0;
int lastIndex = 0, currIndex = 1;
while (currIndex <= spec[0].length()) {
while (currIndex <= spec[0].length() && isInt(spec[0].substring(lastIndex, currIndex))) {
currIndex++;
}
if (currIndex - 1 != lastIndex) {
if (currIndex > spec[0].length()) {
return -1;
}
final String param = spec[0].substring(currIndex - 1, currIndex).toLowerCase();
if (param.equals("d")) {
days = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
} else if (param.equals("h")) {
hours = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
} else if (param.equals("m")) {
minutes = Integer.parseInt(spec[0].substring(lastIndex, currIndex - 1));
}
}
lastIndex = currIndex;
currIndex++;
}
if (days == 0 && hours == 0 && minutes == 0) {
return -1;
}
return minutes + hours * 60 + days * 1440;
} else {
return -1;
}
}
final String timestamp;
if (spec.length == 1) {
if (spec[0].contains(":")) {
timestamp = new SimpleDateFormat("dd.MM.yyyy").format(System.currentTimeMillis()) + " " + spec[0];
} else {
timestamp = spec[0] + " 00:00:00";
}
} else {
timestamp = spec[0] + " " + spec[1];
}
try {
return (int) ((System.currentTimeMillis() - new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").parse(timestamp).getTime()) / 60000);
} catch (final ParseException ex) {
return -1;
}
}
public static String spaces(int count) {
final StringBuilder filled = new StringBuilder(count);
for (int i = 0; i < count; i++) {
filled.append(' ');
}
return filled.toString();
}
public static String join(String[] s, String delimiter) {
if (s == null || s.length == 0) {
return "";
}
final int len = s.length;
final StringBuilder builder = new StringBuilder(s[0]);
for (int i = 1; i < len; i++) {
builder.append(delimiter).append(s[i]);
}
return builder.toString();
}
/**
* Converts a list of arguments e.g ['lb', 'clearlog', 'world', '"my', 'world', 'of', 'swag"']
* into a list of arguments with any text encapsulated by quotes treated as one word
* For this particular example: ['lb', 'clearlog', 'world', '"my world of swag"']
*
* @param args The list of arguments
* @return A new list with the quoted arguments parsed to single values
*/
public static List<String> parseQuotes(List<String> args) {
List<String> newArguments = new ArrayList<>();
String subjectString = join(args.toArray(new String[args.size()]), " ");
Pattern regex = Pattern.compile("[^\\s\"']+|\"[^\"]*\"|'[^']*'");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
newArguments.add(regexMatcher.group());
}
return newArguments;
}
public static class ExtensionFilenameFilter implements FilenameFilter {
private final String ext;
public ExtensionFilenameFilter(String ext) {
this.ext = "." + ext;
}
@Override
public boolean accept(File dir, String name) {
return name.toLowerCase().endsWith(ext);
}
}
private final static char[] hexArray = "0123456789ABCDEF".toCharArray();
public static String mysqlEscapeBytes(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2 + 2];
hexChars[0] = '0';
hexChars[1] = 'x';
for (int j = 0; j < bytes.length; j++) {
int v = bytes[j] & 0xFF;
hexChars[j * 2 + 2] = hexArray[v >>> 4];
hexChars[j * 2 + 3] = hexArray[v & 0x0F];
}
return new String(hexChars);
}
public static String mysqlPrepareBytesForInsertAllowNull(byte[] bytes) {
if (bytes == null) {
return "null";
}
return "'" + mysqlEscapeBytes(bytes) + "'";
}
public static String mysqlTextEscape(String untrusted) {
return untrusted.replace("\\", "\\\\").replace("'", "\\'");
}
public static ItemStack loadItemStack(byte[] data) {
if (data == null || data.length == 0) {
return null;
}
YamlConfiguration conf = deserializeYamlConfiguration(data);
return conf == null ? null : conf.getItemStack("stack");
}
public static byte[] saveItemStack(ItemStack stack) {
if (stack == null || BukkitUtils.isEmpty(stack.getType())) {
return null;
}
YamlConfiguration conf = new YamlConfiguration();
conf.set("stack", stack);
return serializeYamlConfiguration(conf);
}
public static YamlConfiguration deserializeYamlConfiguration(byte[] data) {
if (data == null || data.length == 0) {
return null;
}
YamlConfiguration conf = new YamlConfiguration();
try {
InputStreamReader reader = new InputStreamReader(new GZIPInputStream(new ByteArrayInputStream(data)), "UTF-8");
conf.load(reader);
reader.close();
return conf;
} catch (ZipException | InvalidConfigurationException e) {
LogBlock.getInstance().getLogger().warning("Could not deserialize YamlConfiguration: " + e.getMessage());
return conf;
} catch (IOException e) {
throw new RuntimeException("IOException should be impossible for ByteArrayInputStream", e);
}
}
public static byte[] serializeYamlConfiguration(YamlConfiguration conf) {
if (conf == null || conf.getKeys(false).isEmpty()) {
return null;
}
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(new GZIPOutputStream(baos), "UTF-8");
writer.write(conf.saveToString());
writer.close();
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException("IOException should be impossible for ByteArrayOutputStream", e);
}
}
public static String serializeForSQL(YamlConfiguration conf) {
return mysqlPrepareBytesForInsertAllowNull(serializeYamlConfiguration(conf));
}
}

6
src/main/java/de/diddiz/LogBlock/worldedit/WorldEditHelper.java → src/main/java/de/diddiz/worldedit/WorldEditHelper.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.worldedit;
package de.diddiz.worldedit;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@ -34,7 +34,7 @@ import com.sk89q.worldedit.entity.BaseEntity;
import com.sk89q.worldedit.math.BlockVector3;
import com.sk89q.worldedit.regions.Region;
import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.util.CuboidRegion;
import de.diddiz.util.CuboidRegion;
public class WorldEditHelper {
private static boolean checkedForWorldEdit;
@ -139,7 +139,7 @@ public class WorldEditHelper {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
NBTOutputStream nbtos = new NBTOutputStream(baos);
CompoundTag nbt = state.getNbtData();
LinkedHashMap<String, Tag<?, ?>> value = new LinkedHashMap<>(nbt.getValue());
LinkedHashMap<String, Tag> value = new LinkedHashMap<>(nbt.getValue());
value.put("Health", new FloatTag(20.0f));
value.put("Motion", new ListTag(DoubleTag.class, Arrays.asList(new DoubleTag[] { new DoubleTag(0), new DoubleTag(0), new DoubleTag(0) })));
value.put("Fire", new ShortTag((short) -20));

5
src/main/java/de/diddiz/LogBlock/worldedit/WorldEditLoggingHook.java → src/main/java/de/diddiz/worldedit/WorldEditLoggingHook.java
View File

@ -1,4 +1,4 @@
package de.diddiz.LogBlock.worldedit;
package de.diddiz.worldedit;
import com.sk89q.worldedit.EditSession;
import com.sk89q.worldedit.WorldEdit;
@ -15,7 +15,8 @@ import de.diddiz.LogBlock.LogBlock;
import de.diddiz.LogBlock.Logging;
import de.diddiz.LogBlock.blockstate.BlockStateCodecs;
import de.diddiz.LogBlock.config.Config;
import de.diddiz.LogBlock.util.BukkitUtils;
import de.diddiz.util.BukkitUtils;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;

10
src/main/resources/blockdata.txt
View File

@ -919,10 +919,10 @@
115:15,minecraft:air
116:0,minecraft:enchanting_table
117:0,minecraft:brewing_stand[has_bottle_0=false,has_bottle_1=false,has_bottle_2=false]
118:0,minecraft:cauldron
118:1,minecraft:cauldron
118:2,minecraft:cauldron
118:3,minecraft:cauldron
118:0,minecraft:cauldron[level=0]
118:1,minecraft:cauldron[level=1]
118:2,minecraft:cauldron[level=2]
118:3,minecraft:cauldron[level=3]
118:4,minecraft:air
118:5,minecraft:air
118:6,minecraft:air
@ -1813,7 +1813,7 @@
207:13,minecraft:air
207:14,minecraft:air
207:15,minecraft:air
208:0,minecraft:dirt_path
208:0,minecraft:grass_path
209:0,minecraft:end_gateway
210:0,minecraft:repeating_command_block[conditional=false,facing=down]
210:1,minecraft:repeating_command_block[conditional=false,facing=up]

2
src/main/resources/itemdata.txt
View File

@ -454,7 +454,7 @@
205:0,minecraft:purpur_slab
206:0,minecraft:end_stone_bricks
207:0,minecraft:beetroots
208:0,minecraft:dirt_path
208:0,minecraft:grass_path
209:0,minecraft:end_gateway
210:0,minecraft:repeating_command_block
211:0,minecraft:chain_command_block

4
src/main/resources/plugin.yml
View File

@ -5,8 +5,8 @@ authors: [md_5, ammar2, frymaster]
website: http://dev.bukkit.org/server-mods/logblock/
main: de.diddiz.LogBlock.LogBlock
description: ${project.description}
softdepend: [WorldEdit, WorldGuard]
api-version: 1.20
softdepend: [WorldEdit]
api-version: 1.14
commands:
lb:
description: 'LogBlock plugin commands'

3
src/test/java/de/diddiz/LogBlock/QueryParsingTest.java
View File

@ -1,8 +1,9 @@
package de.diddiz.LogBlock;
import de.diddiz.util.Utils;
import org.junit.Assert;
import org.junit.Test;
import de.diddiz.LogBlock.util.Utils;
import java.util.Arrays;
import java.util.List;