private static void loadPropertiesFiles(File dataFolder) {
// Use Configuration once it's finished.
PropertiesFile pf = new PropertiesFile(new File(dataFolder, "watching.properties"));
blockBreak = pf.getBoolean("blockBreak", true, "Watch when players break blocks");
blockPlace = pf.getBoolean("blockPlace", true, "Watch when players place blocks");
teleport = pf.getBoolean("teleport", true, "Watch when players teleport around");
chestChanges =
pf.getBoolean("chestChanges", true, "Watch when players add/remove items from chests");
commands = pf.getBoolean("commands", true, "Watch for all player commands");
chat = pf.getBoolean("chat", true, "Watch for player chat");
login = pf.getBoolean("login", true, "Watch for player logins");
disconnect = pf.getBoolean("disconnect", true, "Watch for player disconnects");
doorOpen = pf.getBoolean("doorOpen", false, "Watch for when player opens doors");
buttonPress = pf.getBoolean("buttonPress", false, "Watch for when player pushes buttons");
leverSwitch = pf.getBoolean("leverSwitch", false, "Watch for when player switches levers");
fire = pf.getBoolean("fireLogging", true, "Watch for when players start fires");
leafDrops = pf.getBoolean("leafDrops", true, "Watch for when leaves drop");
tntExplosions = pf.getBoolean("tntExplosions", true, "Watch for when TNT explodes");
creeperExplosions =
pf.getBoolean("creeperExplosions", true, "Watch for when Creepers explodes");
miscExplosions = pf.getBoolean("miscExplosions", true, "Watch for miscellaneous explosions");
ipPlayer = pf.getBoolean("ipPlayer", false, "Add player's IP when login");
pf.save();
pf = new PropertiesFile(new File(dataFolder, "BigBrother.properties"));
freedMem = pf.getDouble("freedMem", 0.0, "The amount of memory freed by BB");
stickItem = pf.getLong("stickItem", 280l, "The item used for /bb stick");
restoreFire = pf.getBoolean("restoreFire", false, "Restore fire when rolling back");
autoWatch = pf.getBoolean("autoWatch", true, "Automatically start watching players");
defaultSearchRadius =
pf.getInt("defaultSearchRadius", 2, "Default search radius for bbhere and bbfind");
mysql = pf.getBoolean("MySQL", true, "If true, uses MySQL. If false, uses Sqlite");
flatLog =
pf.getBoolean(
"flatFileLogs", false, "If true, will also log actions to .logs (one for each player)");
mysqlUser = pf.getString("mysqlUser", "root", "Username for MySQL db (if applicable)");
mysqlPass = pf.getString("mysqlPass", "root", "Password for MySQL db (if applicable)");
mysqlDB =
pf.getString(
"mysqlDB", "jdbc:mysql://localhost:3306/minecraft", "DB for MySQL (if applicable)");
BBDataBlock.BBDATA_TABLE_MYSQL =
BBDataBlock.BBDATA_TABLE_MYSQL
+ " ENGINE="
+ pf.getString("engine", "INNODB", "Engine for the Database (INNODB is recommended)")
+ ";";
sendDelay =
pf.getInt("sendDelay", 4, "Delay to batch send updates to database (4-5 recommended)");
pf.save();
}
public DestroySpell(MagicSpellsListener listener, PropertiesFile properties) {
super(listener, properties);
// register spell
listener.registerSpellName(
properties.getString("destroy-spellname", "destroy"),
this,
properties.getString("destroy-desc", "Destroys target blocks"));
// get properties
REDSTONE_COST = properties.getInt("destroy-redstone-cost", 10);
OTHER_COST = properties.getInt("destroy-other-cost-type", 289);
OTHER_COST_NAME = properties.getString("destroy-other-cost-name", "gunpowder");
OTHER_COST_AMT = properties.getInt("destroy-other-cost-amt", 1);
BLAST_RADIUS = properties.getInt("destroy-blast-radius", 2);
STR_CAST = properties.getString("destroy-cast-str", "Boom!");
STR_CAST_OTHERS = properties.getString("destroy-cast-others-str", "Boom!");
// setup reagents
reagents = new int[][] {{REDSTONE_DUST, REDSTONE_COST}, {OTHER_COST, OTHER_COST_AMT}};
}
public static void initialize(File dataFolder) {
if (!dataFolder.exists()) {
dataFolder.mkdirs();
}
File configFile = new File(dataFolder, settingsFile);
PropertiesFile file = new PropertiesFile(configFile);
dataDir = dataFolder;
maxPublic = file.getInt("maxPublic", 5, "Maximum number of public warps any player can make");
maxPrivate =
file.getInt("maxPrivate", 10, "Maximum number of private warps any player can make");
adminsObeyLimits =
file.getBoolean("adminsObeyLimits", false, "Whether or not admins can disobey warp limits");
adminPrivateWarps =
file.getBoolean(
"adminPrivateWarps", true, "Whether or not admins can see private warps in their list");
loadChunks =
file.getBoolean(
"loadChunks",
false,
"Force sending of the chunk which people teleport to - default: false");
usemySQL =
file.getBoolean(
"usemySQL", false, "MySQL usage -- true = use MySQL database / false = use SQLite");
mySQLconn =
file.getString(
"mySQLconn",
"jdbc:mysql://localhost:3306/minecraft",
"MySQL Connection (only if using MySQL)");
mySQLuname = file.getString("mySQLuname", "root", "MySQL Username (only if using MySQL)");
mySQLpass = file.getString("mySQLpass", "password", "MySQL Password (only if using MySQL)");
file.save();
}
public void Load() {
String numkey = "sign-amount";
String signprefix = "sign-";
// clear list
mSensorList.clear();
// save
int num = mPropertiesFile.getInt(numkey, 0);
for (int i = 0; i < num; ++i) {
SensorBlock s = SensorBlock.deserialize(mPropertiesFile.getString(signprefix + i, ""));
if (s != null) {
mSensorList.add(s);
} else {
Logger.getLogger("Minecraft")
.warning(
"[TOWNDEFENSE] Sensor at line "
+ i
+ " could not be deserialized or is invalid. Deleting.");
}
}
TownDefense.Broadcast("Loaded " + mSensorList.size() + " of " + num + " Sensors.");
}
public static Warzone load(String name, boolean createNewVolume) {
// war.getLogger().info("Loading warzone " + name + " config and blocks...");
PropertiesFile warzoneConfig =
new PropertiesFile(War.war.getDataFolder().getPath() + "/warzone-" + name + ".txt");
try {
warzoneConfig.load();
} catch (IOException e) {
War.war.getLogger().info("Failed to load warzone-" + name + ".txt file.");
e.printStackTrace();
}
// world
String worldStr = warzoneConfig.getProperty("world");
World world = null;
if (worldStr == null || worldStr.equals("")) {
world = War.war.getServer().getWorlds().get(0); // default to first world
} else {
world = War.war.getServer().getWorld(worldStr);
}
if (world == null) {
War.war.log(
"Failed to restore warzone "
+ name
+ ". The specified world (name: "
+ worldStr
+ ") does not exist!",
Level.WARNING);
} else {
// Create the zone
Warzone warzone = new Warzone(world, name);
// Create file if needed
if (!warzoneConfig.containsKey("name")) {
WarzoneTxtMapper.save(warzone, false);
War.war.getLogger().info("Warzone " + name + " config file created.");
try {
warzoneConfig.load();
} catch (IOException e) {
// war.getLogger().info("Failed to reload warzone-" + name + ".txt file after creating
// it.");
e.printStackTrace();
}
}
// teleport
String teleportStr = warzoneConfig.getString("teleport");
if (teleportStr != null && !teleportStr.equals("")) {
String[] teleportSplit = teleportStr.split(",");
int teleX = Integer.parseInt(teleportSplit[0]);
int teleY = Integer.parseInt(teleportSplit[1]);
int teleZ = Integer.parseInt(teleportSplit[2]);
int yaw = Integer.parseInt(teleportSplit[3]);
warzone.setTeleport(new Location(world, teleX, teleY, teleZ, yaw, 0));
}
// ff
if (warzoneConfig.containsKey("friendlyFire")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.FRIENDLYFIRE, warzoneConfig.getBoolean("friendlyFire"));
}
// loadout
warzone.getDefaultInventories().getLoadouts().clear();
String loadoutStr = warzoneConfig.getString("loadout");
if (loadoutStr != null && !loadoutStr.equals("")) {
warzone
.getDefaultInventories()
.getLoadouts()
.put("default", new HashMap<Integer, ItemStack>());
LoadoutTxtMapper.fromStringToLoadout(
loadoutStr, warzone.getDefaultInventories().getLoadouts().get("default"));
}
// extraLoadouts
String extraLoadoutStr = warzoneConfig.getString("extraLoadouts");
String[] extraLoadoutsSplit = extraLoadoutStr.split(",");
for (String nameStr : extraLoadoutsSplit) {
if (nameStr != null && !nameStr.equals("")) {
warzone
.getDefaultInventories()
.getLoadouts()
.put(nameStr, new HashMap<Integer, ItemStack>());
}
}
for (String extraName : extraLoadoutsSplit) {
if (extraName != null && !extraName.equals("")) {
String loadoutString = warzoneConfig.getString(extraName + "Loadout");
HashMap<Integer, ItemStack> loadout =
warzone.getDefaultInventories().getLoadouts().get(extraName);
LoadoutTxtMapper.fromStringToLoadout(loadoutString, loadout);
}
}
// authors
if (warzoneConfig.containsKey("author") && !warzoneConfig.getString("author").equals("")) {
for (String authorStr : warzoneConfig.getString("author").split(",")) {
if (!authorStr.equals("")) {
warzone.addAuthor(authorStr);
}
}
}
// life pool (always set after teams, so the teams' remaining lives get initialized properly
// by this setter)
if (warzoneConfig.containsKey("lifePool")) {
warzone.getTeamDefaultConfig().put(TeamConfig.LIFEPOOL, warzoneConfig.getInt("lifePool"));
}
// monument heal
if (warzoneConfig.containsKey("monumentHeal")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.MONUMENTHEAL, warzoneConfig.getInt("monumentHeal"));
}
// autoAssignOnly
if (warzoneConfig.containsKey("autoAssignOnly")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.AUTOASSIGN, warzoneConfig.getBoolean("autoAssignOnly"));
}
// flagPointsOnly
if (warzoneConfig.containsKey("flagPointsOnly")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGPOINTSONLY, warzoneConfig.getBoolean("flagPointsOnly"));
}
// flagMustBeHome
if (warzoneConfig.containsKey("flagMustBeHome")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGMUSTBEHOME, warzoneConfig.getBoolean("flagMustBeHome"));
}
// team cap
if (warzoneConfig.containsKey("teamCap")) {
warzone.getTeamDefaultConfig().put(TeamConfig.TEAMSIZE, warzoneConfig.getInt("teamCap"));
}
// score cap
if (warzoneConfig.containsKey("scoreCap")) {
warzone.getTeamDefaultConfig().put(TeamConfig.MAXSCORE, warzoneConfig.getInt("scoreCap"));
}
// respawn timer
if (warzoneConfig.containsKey("respawnTimer")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.RESPAWNTIMER, warzoneConfig.getInt("respawnTimer"));
}
// blockHeads
if (warzoneConfig.containsKey("blockHeads")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.BLOCKHEADS, warzoneConfig.getBoolean("blockHeads"));
}
// spawnStyle
String spawnStyle = warzoneConfig.getString("spawnStyle");
if (spawnStyle != null && !spawnStyle.equals("")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.SPAWNSTYLE, TeamSpawnStyle.getStyleFromString(spawnStyle));
}
// flagReturn
String flagReturn = warzoneConfig.getString("flagReturn");
if (flagReturn != null && !flagReturn.equals("")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.FLAGRETURN, FlagReturn.getFromString(flagReturn));
}
// reward
String rewardStr = warzoneConfig.getString("reward");
if (rewardStr != null && !rewardStr.equals("")) {
HashMap<Integer, ItemStack> reward = new HashMap<Integer, ItemStack>();
LoadoutTxtMapper.fromStringToLoadout(rewardStr, reward);
warzone.getDefaultInventories().setReward(reward);
}
// unbreakableZoneBlocks
if (warzoneConfig.containsKey("unbreakableZoneBlocks")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.UNBREAKABLE, warzoneConfig.getBoolean("unbreakableZoneBlocks"));
}
// disabled
if (warzoneConfig.containsKey("disabled")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.DISABLED, warzoneConfig.getBoolean("disabled"));
}
// noCreatures
if (warzoneConfig.containsKey("noCreatures")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.NOCREATURES, warzoneConfig.getBoolean("noCreatures"));
}
// glassWalls
if (warzoneConfig.containsKey("glassWalls")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.GLASSWALLS, warzoneConfig.getBoolean("glassWalls"));
}
// pvpInZone
if (warzoneConfig.containsKey("pvpInZone")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.PVPINZONE, warzoneConfig.getBoolean("pvpInZone"));
}
// instaBreak
if (warzoneConfig.containsKey("instaBreak")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.INSTABREAK, warzoneConfig.getBoolean("instaBreak"));
}
// noDrops
if (warzoneConfig.containsKey("noDrops")) {
warzone.getWarzoneConfig().put(WarzoneConfig.NODROPS, warzoneConfig.getBoolean("noDrops"));
}
// noHunger
if (warzoneConfig.containsKey("noHunger")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.NOHUNGER, warzoneConfig.getBoolean("noHunger"));
}
// saturation
if (warzoneConfig.containsKey("saturation")) {
warzone
.getTeamDefaultConfig()
.put(TeamConfig.SATURATION, warzoneConfig.getInt("saturation"));
}
// minPlayers
if (warzoneConfig.containsKey("minPlayers")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.MINPLAYERS, warzoneConfig.getInt("minPlayers"));
}
// minTeams
if (warzoneConfig.containsKey("minTeams")) {
warzone.getWarzoneConfig().put(WarzoneConfig.MINTEAMS, warzoneConfig.getInt("minTeams"));
}
// resetOnEmpty
if (warzoneConfig.containsKey("resetOnEmpty")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONEMPTY, warzoneConfig.getBoolean("resetOnEmpty"));
}
// resetOnLoad
if (warzoneConfig.containsKey("resetOnLoad")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONLOAD, warzoneConfig.getBoolean("resetOnLoad"));
}
// resetOnUnload
if (warzoneConfig.containsKey("resetOnUnload")) {
warzone
.getWarzoneConfig()
.put(WarzoneConfig.RESETONUNLOAD, warzoneConfig.getBoolean("resetOnUnload"));
}
// rallyPoint
String rallyPointStr = warzoneConfig.getString("rallyPoint");
if (rallyPointStr != null && !rallyPointStr.equals("")) {
String[] rallyPointStrSplit = rallyPointStr.split(",");
int rpX = Integer.parseInt(rallyPointStrSplit[0]);
int rpY = Integer.parseInt(rallyPointStrSplit[1]);
int rpZ = Integer.parseInt(rallyPointStrSplit[2]);
Location rallyPoint = new Location(world, rpX, rpY, rpZ);
warzone.setRallyPoint(rallyPoint);
}
// monuments
String monumentsStr = warzoneConfig.getString("monuments");
if (monumentsStr != null && !monumentsStr.equals("")) {
String[] monumentsSplit = monumentsStr.split(";");
warzone.getMonuments().clear();
for (String monumentStr : monumentsSplit) {
if (monumentStr != null && !monumentStr.equals("")) {
String[] monumentStrSplit = monumentStr.split(",");
int monumentX = Integer.parseInt(monumentStrSplit[1]);
int monumentY = Integer.parseInt(monumentStrSplit[2]);
int monumentZ = Integer.parseInt(monumentStrSplit[3]);
Monument monument =
new Monument(
monumentStrSplit[0],
warzone,
new Location(world, monumentX, monumentY, monumentZ));
warzone.getMonuments().add(monument);
}
}
}
// teams
String teamsStr = warzoneConfig.getString("teams");
if (teamsStr != null && !teamsStr.equals("")) {
String[] teamsSplit = teamsStr.split(";");
warzone.getTeams().clear();
for (String teamStr : teamsSplit) {
if (teamStr != null && !teamStr.equals("")) {
String[] teamStrSplit = teamStr.split(",");
int teamX = Integer.parseInt(teamStrSplit[1]);
int teamY = Integer.parseInt(teamStrSplit[2]);
int teamZ = Integer.parseInt(teamStrSplit[3]);
Location teamLocation = new Location(world, teamX, teamY, teamZ);
if (teamStrSplit.length > 4) {
int yaw = Integer.parseInt(teamStrSplit[4]);
teamLocation.setYaw(yaw);
}
Team team =
new Team(
teamStrSplit[0],
TeamKind.teamKindFromString(teamStrSplit[0]),
teamLocation,
warzone);
team.setRemainingLives(warzone.getTeamDefaultConfig().resolveInt(TeamConfig.LIFEPOOL));
warzone.getTeams().add(team);
}
}
}
// teamFlags
String teamFlagsStr = warzoneConfig.getString("teamFlags");
if (teamFlagsStr != null && !teamFlagsStr.equals("")) {
String[] teamFlagsSplit = teamFlagsStr.split(";");
for (String teamFlagStr : teamFlagsSplit) {
if (teamFlagStr != null && !teamFlagStr.equals("")) {
String[] teamFlagStrSplit = teamFlagStr.split(",");
Team team = warzone.getTeamByKind(TeamKind.teamKindFromString(teamFlagStrSplit[0]));
if (team != null) {
int teamFlagX = Integer.parseInt(teamFlagStrSplit[1]);
int teamFlagY = Integer.parseInt(teamFlagStrSplit[2]);
int teamFlagZ = Integer.parseInt(teamFlagStrSplit[3]);
Location teamFlagLocation = new Location(world, teamFlagX, teamFlagY, teamFlagZ);
if (teamFlagStrSplit.length > 4) {
int yaw = Integer.parseInt(teamFlagStrSplit[4]);
teamFlagLocation.setYaw(yaw);
}
team.setTeamFlag(teamFlagLocation); // this may screw things up
}
}
}
}
// lobby
String lobbyStr = warzoneConfig.getString("lobby");
warzoneConfig.close();
if (createNewVolume) {
ZoneVolume zoneVolume =
new ZoneVolume(
warzone.getName(),
world,
warzone); // VolumeMapper.loadZoneVolume(warzone.getName(), warzone.getName(), war,
// warzone.getWorld(), warzone);
warzone.setVolume(zoneVolume);
}
// monument blocks
for (Monument monument : warzone.getMonuments()) {
monument.setVolume(VolumeMapper.loadVolume(monument.getName(), warzone.getName(), world));
}
// team spawn blocks
for (Team team : warzone.getTeams()) {
team.setSpawnVolume(VolumeMapper.loadVolume(team.getName(), warzone.getName(), world));
if (team.getTeamFlag() != null) {
team.setFlagVolume(
VolumeMapper.loadVolume(team.getName() + "flag", warzone.getName(), world));
}
}
// lobby
BlockFace lobbyFace = null;
if (lobbyStr != null && !lobbyStr.equals("")) {
String[] lobbyStrSplit = lobbyStr.split(",");
if (lobbyStrSplit.length > 0) {
// lobby orientation
if (lobbyStrSplit[0].equals("south")) {
lobbyFace = Direction.SOUTH();
} else if (lobbyStrSplit[0].equals("east")) {
lobbyFace = Direction.EAST();
} else if (lobbyStrSplit[0].equals("north")) {
lobbyFace = Direction.NORTH();
} else if (lobbyStrSplit[0].equals("west")) {
lobbyFace = Direction.WEST();
}
// lobby world
World lobbyWorld = world; // by default, warzone world
if (lobbyStrSplit.length > 1) {
World strWorld = War.war.getServer().getWorld(lobbyStrSplit[1]);
if (strWorld != null) {
lobbyWorld = strWorld;
}
}
// create the lobby
Volume lobbyVolume = VolumeMapper.loadVolume("lobby", warzone.getName(), lobbyWorld);
ZoneLobby lobby = new ZoneLobby(warzone, lobbyFace, lobbyVolume);
warzone.setLobby(lobby);
}
}
return warzone;
}
return null;
}
/** Loads or reloads the mod */
public final void load() {
if (properties == null) {
properties = new PropertiesFile("server.properties");
} else {
try {
properties.load();
} catch (IOException e) {
log.log(Level.SEVERE, "Exception while reading from server.properties", e);
}
}
try {
dataSourceType = properties.getString("data-source", "flatfile");
allowedItems = properties.getString("alloweditems", "").split(",");
disallowedItems = properties.getString("disalloweditems", "").split(",");
itemSpawnBlacklist = properties.getString("itemspawnblacklist", "").split(",");
motd = properties.getString("motd", "Type /help for a list of commands.").split("@");
playerLimit = properties.getInt("max-players", 20);
saveHomes = properties.getBoolean("save-homes", true);
whitelistEnabled = properties.getBoolean("whitelist", false);
whitelistMessage = properties.getString("whitelist-message", "Not on whitelist.");
if (dataSourceType.equalsIgnoreCase("flatfile")) {
usersLoc = properties.getString("admintxtlocation", "users.txt");
kitsLoc = properties.getString("kitstxtlocation", "kits.txt");
homeLoc = properties.getString("homelocation", "homes.txt");
warpLoc = properties.getString("warplocation", "warps.txt");
itemLoc = properties.getString("itemstxtlocation", "items.txt");
groupLoc = properties.getString("group-txt-location", "groups.txt");
whitelistLoc = properties.getString("whitelist-txt-location", "whitelist.txt");
reservelistLoc = properties.getString("reservelist-txt-location", "reservelist.txt");
} else {
PropertiesFile sql = new PropertiesFile("mysql.properties");
driver = sql.getString("driver", "com.mysql.jdbc.Driver");
username = sql.getString("user", "root");
password = sql.getString("pass", "root");
db = sql.getString("db", "jdbc:mysql://localhost:3306/minecraft");
}
spawnProtectionSize = properties.getInt("spawn-protection-size", 16);
logging = properties.getBoolean("logging", false);
enableHealth = properties.getBoolean("enable-health", true);
String autoHealString = properties.getString("auto-heal", "default");
if (autoHealString.equalsIgnoreCase("true")) {
autoHeal = PluginLoader.HookResult.ALLOW_ACTION;
} else if (autoHealString.equalsIgnoreCase("false")) {
autoHeal = PluginLoader.HookResult.PREVENT_ACTION;
}
showUnknownCommand = properties.getBoolean("show-unknown-command", true);
URL url = this.getClass().getResource("/version.txt");
if (url != null) {
InputStreamReader ins = new InputStreamReader(url.openStream());
BufferedReader bufferedReader = new BufferedReader(ins);
String versionParam = bufferedReader.readLine();
if (versionParam.startsWith(
"git-")) { // recommended version.txt for git builds: git-<gituser>-<shorttag>
// example: git-sk89q-591c662cf4afc8e3e09a
version = -1;
versionStr = versionParam;
tainted = true;
} else {
version = Integer.parseInt(versionParam);
versionStr = Integer.toString(version); // and back to a string.
tainted = false; // looks official. We hope.
}
} else {
// I'm a tainted build, probably.
version = -1;
versionStr = "Undefined version";
tainted = true;
// If any mods check the version.. #@!$
}
} catch (Exception e) {
log.log(Level.SEVERE, "Exception while reading from server.properties", e);
// Just in case...
disallowedItems = new String[] {""};
allowedItems = new String[] {""};
itemSpawnBlacklist = new String[] {""};
motd = new String[] {"Type /help for a list of commands."};
}
}
