Пример #1
0
 public HashSet<String> getRecognitionList() {
   String[] result = _entry.getProperty("recognition").split(",");
   HashSet<String> set = new HashSet<String>();
   for (int i = 0; i < result.length; i++) {
     set.add(result[i]);
   }
   return set;
 }
Пример #2
0
  public static void loadSettings() {

    if (!new File("/plugins/config/WorldTools/MySQL.properties").exists()) {
      try {
        File f = new File("plugins/config/WorldTools/MySQL.properties");
        BufferedWriter out = new BufferedWriter(new FileWriter(f));
        out.write("############################");
        out.newLine();
        out.write("# THIS IS CURRENTLY UNUSED #");
        out.newLine();
        out.write("############################");
        out.newLine();
        out.write("useCanarySQL=true");
        out.newLine();
        out.newLine();
        out.write("SQLdriver=com.mysql.jdbc.Driver");
        out.newLine();
        out.newLine();
        out.write("SQLuser=root");
        out.newLine();
        out.newLine();
        out.write("SQLpass=root");
        out.newLine();
        out.newLine();
        out.write("SQLdb=jdbc:mysql://localhost:3306/minecraft");
        out.newLine();
        out.newLine();
      } catch (IOException e) {
        log.info("[WorldTools] - Error during creating SQL propertiesfile!");
        e.printStackTrace();
      }
    }
    PropertiesFile properties = new PropertiesFile("/plugins/config/WorldTools/MySQL.properties");
    try {
      SQLdriver = properties.getProperty("SQLdriver");
      SQLusername = properties.getProperty("SQLuser");
      SQLpassword = properties.getProperty("SQLpass");
      SQLdb = properties.getProperty("SQLdb");
      useSql = Boolean.parseBoolean(properties.getProperty("UseCanarySQL"));
    } catch (Exception e) {
      log.log(Level.SEVERE, "Exception while reading from the mysql properties", e);
    }
    getConnection();
  }
Пример #3
0
 public String getBusybox(boolean select) {
   String version = "";
   if (!select) version = _entry.getProperty("busyboxhelper");
   else {
     version = WidgetTask.openBusyboxSelector(Display.getCurrent().getActiveShell());
     // BusyBoxSelectGUI sel = new BusyBoxSelectGUI(getId());
     // version = sel.getVersion();
   }
   if (version.length() == 0) return "";
   else return "." + fsep + "devices" + fsep + "busybox" + fsep + version + fsep + "busybox";
 }
Пример #4
0
 public boolean canFlash() {
   return _entry.getProperty("canflash").equals("true");
 }
Пример #5
0
 public String getBuildId() {
   return _entry.getProperty("android.build");
 }
Пример #6
0
 public String getVersion() {
   return _entry.getProperty("android.release");
 }
Пример #7
0
 public String getId() {
   return _entry.getProperty("internalname");
 }
Пример #8
0
 public String getKernelVersion() {
   return _entry.getProperty("kernel.version");
 }
Пример #9
0
 public String getBuildMerge() {
   return "./devices/" + _entry.getProperty("internalname") + "/build.prop";
 }
Пример #10
0
 public String getBusyBoxInstallPath() {
   return _entry.getProperty("busyboxinstallpath");
 }
Пример #11
0
 public String getLoaderUnlockedMD5() {
   return _entry.getProperty("loader_unlocked").toUpperCase();
 }
Пример #12
0
 public String getLoaderMD5() {
   return _entry.getProperty("loader").toUpperCase();
 }
Пример #13
0
 public String getBuildProp() {
   return _entry.getProperty("buildprop");
 }
Пример #14
0
 public String getName() {
   return _entry.getProperty("realname");
 }
Пример #15
0
 public boolean canKernel() {
   return (_entry.getProperty("cankernel").equals("true"));
 }
Пример #16
0
 public boolean canFastboot() {
   return _entry.getProperty("canfastboot").equals("true");
 }
Пример #17
0
 public String getRecognition() {
   return _entry.getProperty("recognition");
 }
Пример #18
0
 public String getOptimize() {
   return "./devices/" + _entry.getProperty("internalname") + "/optimize.tar";
 }
Пример #19
0
 public String getVariant() {
   String variant = _entry.getProperty("variant");
   if (variant == null) return getId();
   return variant;
 }
Пример #20
0
 public String getCharger() {
   return "./devices/" + _entry.getProperty("internalname") + "/charger";
 }
Пример #21
0
 public void addRecognitionToList(String recog) {
   String current = _entry.getProperty("recognition");
   current = current + "," + recog;
   _entry.setProperty("recognition", current);
   _entry.write("ISO-8859-1");
 }
Пример #22
0
  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;
  }
Пример #23
0
 public String getLoaderUnlocked() {
   return "./devices/" + _entry.getProperty("internalname") + "/loader_unlocked.sin";
 }