예제 #1
0
 public boolean startRound() {
   /// trying to start when we havent created anything yet
   /// or event was canceled/closed
   if (round < 0 || state == EventState.CLOSED) {
     return false;
   }
   announceRound();
   Plugin plugin = BattleArena.getSelf();
   /// Section to start the match
   curTimer =
       plugin
           .getServer()
           .getScheduler()
           .scheduleSyncDelayedTask(
               plugin,
               new Runnable() {
                 public void run() {
                   Round tr = rounds.get(round);
                   for (Matchup m : tr.getMatchups()) {
                     ac.addMatchup(m);
                   }
                 }
               },
               (long) (timeBetweenRounds * 20L * Defaults.TICK_MULT));
   return true;
 }
예제 #2
0
  public void start() {
    System.out.println("Arena::onStart " + timedSpawns);
    if (timedSpawns != null && !timedSpawns.isEmpty()) {
      Plugin plugin = BattleArena.getSelf();
      /// Create our Q, with a descending Comparator
      spawnQ =
          new PriorityQueue<NextSpawn>(
              timedSpawns.size(),
              new Comparator<NextSpawn>() {
                public int compare(NextSpawn o1, NextSpawn o2) {
                  return (o1.timeToNext.compareTo(o2.timeToNext));
                }
              });
      /// TeamJoinResult our items into the Q
      ArrayList<NextSpawn> nextspawns = new ArrayList<NextSpawn>();
      for (TimedSpawn is : timedSpawns.values()) {
        //				System.out.println("itemSpawns = " + timedSpawns.size() + " " +
        // is.getFirstSpawnTime()+ "  ts=" + is);
        long tts = is.getFirstSpawnTime();
        if (tts == 0) is.spawn();
        NextSpawn ns = new NextSpawn(is, tts);
        spawnQ.add(ns);
        nextspawns.add(ns);
      }

      timerId =
          plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new SpawnNextEvent(0L));
    }
  }
 private static BaseSerializer getSerializer(String name) {
   BaseSerializer bs = new BaseSerializer();
   File dir = new File(BattleArena.getSelf().getDataFolder() + "/inventories/");
   if (!dir.exists()) {
     dir.mkdirs();
   }
   return bs.setConfig(dir.getPath() + "/" + name + ".yml") ? bs : null;
 }
  public static void saveInventory(final String name, final PInv pinv) {
    if (Defaults.NUM_INV_SAVES <= 0) {
      return;
    }
    Bukkit.getScheduler()
        .scheduleAsyncDelayedTask(
            BattleArena.getSelf(),
            new Runnable() {
              @Override
              public void run() {
                BaseSerializer serializer = getSerializer(name);
                if (serializer == null) return;
                Date now = new Date();
                String date =
                    DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG).format(now);
                int curSection = serializer.config.getInt("curSection", 0);
                serializer.config.set("curSection", (curSection + 1) % Defaults.NUM_INV_SAVES);
                ConfigurationSection pcs = serializer.config.createSection(curSection + "");
                pcs.set("storedDate", date);
                List<String> stritems = new ArrayList<String>();
                for (ItemStack is : pinv.armor) {
                  if (is == null || is.getType() == Material.AIR) continue;
                  stritems.add(InventoryUtil.getItemString(is));
                }
                pcs.set("armor", stritems);

                stritems = new ArrayList<String>();
                for (ItemStack is : pinv.contents) {
                  if (is == null || is.getType() == Material.AIR) continue;
                  stritems.add(InventoryUtil.getItemString(is));
                }
                pcs.set("contents", stritems);
                serializer.save();
              }
            });
  }
예제 #5
0
 public TournamentEvent(EventParams params) {
   super(params);
   oParms = params;
   Bukkit.getPluginManager().registerEvents(this, BattleArena.getSelf());
 }
예제 #6
0
 public SpawnController(Map<Long, TimedSpawn> spawnGroups) {
   this.timedSpawns = spawnGroups;
   plugin = BattleArena.getSelf();
 }
예제 #7
0
  @ArenaEventHandler(bukkitPriority = org.bukkit.event.EventPriority.MONITOR)
  public void onPlayerDeath(ArenaPlayerDeathEvent event) {
    final ArenaPlayer target = event.getPlayer();
    if (state == MatchState.ONCANCEL || state == MatchState.ONCOMPLETE) {
      return;
    }
    final ArenaTeam t = event.getTeam();

    Integer nDeaths = t.addDeath(target);
    boolean exiting = event.isExiting() || !respawns || nDeaths >= nLivesPerPlayer;
    event.setExiting(exiting);
    final boolean trueDeath = event.getPlayerDeathEvent() != null;
    if (nLivesPerPlayer != ArenaSize.MAX) {
      int curLives = nLivesPerPlayer - nDeaths;
      SEntry e = scoreboard.getEntry(target.getPlayer());
      if (e != null) scoreboard.setEntryNameSuffix(e, curLives <= 1 ? "" : "&4(" + curLives + ")");
    }
    if (trueDeath) {
      PlayerDeathEvent pde = event.getPlayerDeathEvent();
      if (cancelExpLoss) pde.setKeepLevel(true);

      /// Handle Drops from bukkitEvent
      if (clearsInventoryOnDeath || keepsInventory) { // / clear the drops
        try {
          pde.getDrops().clear();
        } catch (Exception e) {
          if (!Defaults.DEBUG_VIRTUAL) Log.printStackTrace(e);
        }
      } else if (woolTeams) { /// Get rid of the wool from teams so it doesnt drop
        final int index = t.getIndex();
        ItemStack teamHead = TeamUtil.getTeamHead(index);
        List<ItemStack> items = pde.getDrops();
        for (ItemStack is : items) {
          if (is.getType() == teamHead.getType()
              && is.getDurability() == teamHead.getDurability()) {
            final int amt = is.getAmount();
            if (amt > 1) is.setAmount(amt - 1);
            else is.setType(Material.AIR);
            break;
          }
        }
      }
      /// If keepInventory is specified, but not restoreAll, then we have a case
      /// where we need to give them back the current Inventory they have on them
      /// even if they log out
      if (keepsInventory) {
        boolean restores =
            getParams().hasOptionAt(MatchState.ONLEAVE, TransitionOption.RESTOREITEMS);
        /// Restores and exiting, means clear their match inventory so they won't
        /// get their match and their already stored inventory
        if (restores && exiting) {
          psc.clearMatchItems(target);
        } else { /// keep their current inv
          psc.storeMatchItems(target);
        }
      }
      /// We can't let them just sit on the respawn screen... schedule them to lose
      /// We will cancel this onRespawn
      final ArenaMatch am = this;
      Integer timer = deathTimer.get(target.getName());
      if (timer != null) {
        Bukkit.getScheduler().cancelTask(timer);
      }
      timer =
          Bukkit.getScheduler()
              .scheduleSyncDelayedTask(
                  BattleArena.getSelf(),
                  new Runnable() {
                    @Override
                    public void run() {
                      PerformTransition.transition(am, MatchState.ONCOMPLETE, target, t, true);
                      checkAndHandleIfTeamDead(t);
                    }
                  },
                  15 * 20L);
      deathTimer.put(target.getName(), timer);
    }
    if (exiting) {
      PerformTransition.transition(this, MatchState.ONCOMPLETE, target, t, true);
      checkAndHandleIfTeamDead(t);
    }
  }
예제 #8
0
  @ArenaEventHandler(priority = EventPriority.HIGH)
  public void onPlayerRespawn(PlayerRespawnEvent event, final ArenaPlayer p) {
    if (Defaults.DEBUG_TRACE) MessageUtil.sendMessage(p, " -onPlayerRespawn  t=" + p.getTeam());

    if (isWon()) {
      return;
    }
    final TransitionOptions mo = tops.getOptions(MatchState.ONDEATH);

    if (mo == null) return;

    if (respawns) {
      final boolean randomRespawn = mo.randomRespawn();
      /// Lets cancel our death respawn timer
      Integer timer = deathTimer.get(p.getName());
      if (timer != null) {
        Bukkit.getScheduler().cancelTask(timer);
      }
      final Location loc;
      final ArenaTeam t = getTeam(p);
      if (mo.hasAnyOption(
          TransitionOption.TELEPORTLOBBY,
          TransitionOption.TELEPORTMAINLOBBY,
          TransitionOption.TELEPORTWAITROOM,
          TransitionOption.TELEPORTMAINWAITROOM)) {
        final int index = t.getIndex();
        if (mo.hasOption(TransitionOption.TELEPORTLOBBY)) {
          loc = RoomController.getLobbySpawn(index, getParams().getType(), randomRespawn);
        } else if (mo.hasOption(TransitionOption.TELEPORTMAINLOBBY)) {
          loc =
              RoomController.getLobbySpawn(
                  Defaults.MAIN_SPAWN, getParams().getType(), randomRespawn);
        } else if (mo.hasOption(TransitionOption.TELEPORTMAINWAITROOM)) {
          loc = this.getWaitRoomSpawn(Defaults.MAIN_SPAWN, randomRespawn);
        } else {
          loc = this.getWaitRoomSpawn(index, randomRespawn);
        }
        /// Should we respawn the player to the team spawn after a certain amount of time
        if (mo.hasOption(TransitionOption.RESPAWNTIME)) {
          int id =
              Bukkit.getScheduler()
                  .scheduleSyncDelayedTask(
                      BattleArena.getSelf(),
                      new Runnable() {
                        @Override
                        public void run() {
                          Integer id = respawnTimer.remove(p.getName());
                          Bukkit.getScheduler().cancelTask(id);
                          Location loc =
                              getTeamSpawn(
                                  index,
                                  tops.hasOptionAt(
                                      MatchState.ONSPAWN, TransitionOption.RANDOMRESPAWN));
                          TeleportController.teleport(p.getPlayer(), loc);
                        }
                      },
                      mo.getRespawnTime() * 20);
          respawnTimer.put(p.getName(), id);
        }
      } else {
        loc = getTeamSpawn(getTeam(p), randomRespawn);
      }

      event.setRespawnLocation(loc);
      /// For some reason, the player from onPlayerRespawn Event isnt the one in the main thread, so
      // we need to
      /// resync before doing any effects
      final Match am = this;
      Bukkit.getScheduler()
          .scheduleSyncDelayedTask(
              BattleArena.getSelf(),
              new Runnable() {
                public void run() {
                  ArenaTeam t = getTeam(p);
                  PerformTransition.transition(am, MatchState.ONDEATH, p, t, false);
                  PerformTransition.transition(am, MatchState.ONSPAWN, p, t, false);
                  if (respawnsWithClass) {
                    ArenaClass ac = null;
                    if (p.getPreferredClass() != null) {
                      ac = p.getPreferredClass();
                    } else if (p.getCurrentClass() != null) {
                      ac = p.getCurrentClass();
                    }
                    if (ac != null) {
                      ArenaClassController.giveClass(p, ac);
                    }
                  }
                  if (keepsInventory) {
                    psc.restoreMatchItems(p);
                  }
                  if (woolTeams) {
                    TeamUtil.setTeamHead(t.getIndex(), p);
                  }
                }
              });
    } else { /// This player is now out of the system now that we have given the ondeath effects
      Location l =
          tops.hasOptionAt(MatchState.ONLEAVE, TransitionOption.TELEPORTTO)
              ? tops.getOptions(MatchState.ONLEAVE).getTeleportToLoc()
              : oldlocs.get(p.getName());
      if (l != null) event.setRespawnLocation(l);
    }
  }