Propozycja nowego trybu i pracy w jego tworzeniu

HardMCore
Ostatnio napisałem propozycję dotyczącą stworzenia serwera SkyGrid i dłużej myślałem nad tym trybem i po dłuższym czasie wypisałem plusy i minusy tworzenia serwera, oraz, gdyby administracja zgodziła się na przyjęcie propozycji, chętnie pomogę w jej realizacji.
Zalety:
 - Niespotykany, wyjątkowy tryb, serwerów z tym trybem w Polsce już raczej nie ma,
 - Ciekawy odpowiednik SkyBlocka, równie lubiany przez graczy,
 - Niekończąca się rozrywka polegająca na eksplorowaniu świata,
 - Plugin na SkyGrid - ASkyGrid, stworzony przez testybento, znanego z pluginy ASkyBlock,
Wady:
 - Nie mam pomysłu na pluginy - podstawowym będzie ASkyGrid, jednak na własne zakątki graczy potrzebny będzie prawdopodobnie inny plugin typu PreciousStones, jednak jest mały problem - nie znam pluginu, który przeliczałby punkty danego terenu, np. z pluginu PreciousStones, więc nie byłoby żadnej topki, tak jak jest to na reszcie serwerów SkyBlock,
 - Problematyka z ItemShopem i przedmiotami na sprzedaż, lub uprawnieniami danych rang, np. Ultimate nie powinien posiadać latania, bo psuło by to rozgrywkę i styl gry SkyGrida, oraz nie wiele przedmiotów na sprzedaż, jedynie spawnery, jakieś klucze, stoniarki czy pieniądze.

Jeszcze jednym pomysłem mógłby być plugin typu vote, który dawałby graczom możliwość głosowania na różnych rankingach serwerów na właśnie tą serwerownię, a w zamian dostawaliby za to nagrody.

Myślę, że gracze mogą podać również sposoby rozwiązania problemów, inne zalety i pomysły.

Zareaguj
Odpowiedz
.:Reklama:.


HardMCore
Znalazłem w ASkyBlock funkcję przemawiającą za obliczanie topki, myślę, że administracji może się przydać, ja specjalizuję się tylko w pisaniu skryptów, pluginów pisac nie potrafię, dlatego wyślę tylko kod odpowiedzialny za jej przeliczanie, może się komuś z administracji przyda, jeżeli tryb miałby powstać.

Kod:

Kod:
package com.wasteofplastic.askyblock;

import com.google.common.collect.HashMultiset;
import com.google.common.collect.ImmutableMultiset;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.Multisets;
import com.wasteofplastic.askyblock.events.IslandPostLevelEvent;
import com.wasteofplastic.askyblock.events.IslandPreLevelEvent;
import com.wasteofplastic.askyblock.util.Util;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.logging.Logger;
import org.apache.commons.lang.math.NumberUtils;
import org.bukkit.ChatColor;
import org.bukkit.Chunk;
import org.bukkit.ChunkSnapshot;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.material.MaterialData;
import org.bukkit.permissions.PermissionAttachmentInfo;
import org.bukkit.plugin.PluginManager;
import org.bukkit.scheduler.BukkitScheduler;

public class LevelCalcByChunk
{
 private List<String> reportLines = new ArrayList();
 
 public LevelCalcByChunk(ASkyBlock plugin, UUID targetPlayer, CommandSender asker)
 {
   this(plugin, targetPlayer, asker, false);
 }
 
 public LevelCalcByChunk(final ASkyBlock plugin, final UUID targetPlayer, final CommandSender sender, final boolean report)
 {
   final Island island = plugin.getGrid().getIsland(targetPlayer);
   if (island != null)
   {
     Player player = plugin.getServer().getPlayer(targetPlayer);
     int multiplier = 1;
     if (player != null) {
       for (PermissionAttachmentInfo perms : player.getEffectivePermissions())
       {
         if (perms.getPermission().startsWith("askyblock.island.multiplier."))
         {
           String[] spl = perms.getPermission().split("askyblock.island.multiplier.");
           if (spl.length > 1) {
             if (!NumberUtils.isDigits(spl[1])) {
               plugin.getLogger().severe("Player " + player.getName() + " has permission: " + perms.getPermission() + " <-- the last part MUST be a number! Ignoring...");
             } else {
               multiplier = Math.max(multiplier, Integer.valueOf(spl[1]).intValue());
             }
           }
         }
         if (multiplier < 1) {
           multiplier = 1;
         }
       }
     }
     final int levelMultiplier = multiplier;
     
     final int levelHandicap = island.getLevelHandicap();
     
     int deaths = plugin.getPlayers().getDeaths(targetPlayer);
     if (plugin.getPlayers().inTeam(targetPlayer))
     {
       deaths = plugin.getPlayers().getDeaths(plugin.getPlayers().getTeamLeader(targetPlayer));
       if (Settings.sumTeamDeaths)
       {
         deaths = 0;
         for (UUID member : plugin.getPlayers().getMembers(targetPlayer)) {
           deaths += plugin.getPlayers().getDeaths(member);
         }
       }
     }
     final int deathHandicap = deaths;
     
     World world = plugin.getPlayers().getIslandLocation(targetPlayer).getWorld();
     

     Set<ChunkSnapshot> chunkSnapshot = new HashSet();
     for (int x = island.getMinProtectedX(); x < island.getMinProtectedX() + island.getProtectionSize() + 16; x += 16) {
       for (int z = island.getMinProtectedZ(); z < island.getMinProtectedZ() + island.getProtectionSize() + 16; z += 16) {
         if (!world.getBlockAt(x, 0, z).getChunk().isLoaded())
         {
           world.getBlockAt(x, 0, z).getChunk().load();
           chunkSnapshot.add(world.getBlockAt(x, 0, z).getChunk().getChunkSnapshot());
           world.getBlockAt(x, 0, z).getChunk().unload();
         }
         else
         {
           chunkSnapshot.add(world.getBlockAt(x, 0, z).getChunk().getChunkSnapshot());
         }
       }
     }
     final Set<ChunkSnapshot> finalChunk = chunkSnapshot;
     final int worldHeight = world.getMaxHeight();
     
     plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable()
     {
       public void run()
       {
         File log = null;
         PrintWriter out = null;
         List<MaterialData> mdLog = null;
         List<MaterialData> uwLog = null;
         List<MaterialData> noCountLog = null;
         List<MaterialData> overflowLog = null;
         if (Settings.levelLogging)
         {
           log = new File(plugin.getDataFolder(), "level.log");
           try
           {
             if (log.exists()) {
               out = new PrintWriter(new FileWriter(log, true));
             } else {
               out = new PrintWriter(log);
             }
           }
           catch (FileNotFoundException e)
           {
             System.out.println("Level log (level.log) could not be opened...");
             e.printStackTrace();
           }
           catch (IOException e)
           {
             System.out.println("Level log (level.log) could not be opened...");
             e.printStackTrace();
           }
         }
         if ((Settings.levelLogging) || (report))
         {
           mdLog = new ArrayList();
           uwLog = new ArrayList();
           noCountLog = new ArrayList();
           overflowLog = new ArrayList();
         }
         HashMap<MaterialData, Integer> limitCount = new HashMap(Settings.blockLimits);
         
         long blockCount = 0L;
         long underWaterBlockCount = 0L;
         for (ChunkSnapshot chunk : finalChunk) {
           for (int x = 0; x < 16; x++) {
             if ((chunk.getX() * 16 + x >= island.getMinProtectedX()) && (chunk.getX() * 16 + x < island.getMinProtectedX() + island.getProtectionSize())) {
               for (int z = 0; z < 16; z++) {
                 if ((chunk.getZ() * 16 + z >= island.getMinProtectedZ()) && (chunk.getZ() * 16 + z < island.getMinProtectedZ() + island.getProtectionSize())) {
                   for (int y = 0; y < worldHeight; y++)
                   {
                     int type = chunk.getBlockTypeId(x, y, z);
                     int data = chunk.getBlockData(x, y, z);
                     MaterialData md = new MaterialData(type, (byte)data);
                     MaterialData generic = new MaterialData(type);
                     if (type != 0) {
                       if ((limitCount.containsKey(md)) && (Settings.blockValues.containsKey(md)))
                       {
                         int count = ((Integer)limitCount.get(md)).intValue();
                         if (count > 0)
                         {
                           limitCount.put(md, Integer.valueOf(--count));
                           if ((Settings.seaHeight > 0) && (y <= Settings.seaHeight))
                           {
                             underWaterBlockCount += ((Integer)Settings.blockValues.get(md)).intValue();
                             if ((Settings.levelLogging) || (report)) {
                               uwLog.add(md);
                             }
                           }
                           else
                           {
                             blockCount += ((Integer)Settings.blockValues.get(md)).intValue();
                             if ((Settings.levelLogging) || (report)) {
                               mdLog.add(md);
                             }
                           }
                         }
                         else if ((Settings.levelLogging) || (report))
                         {
                           overflowLog.add(md);
                         }
                       }
                       else if ((limitCount.containsKey(generic)) && (Settings.blockValues.containsKey(generic)))
                       {
                         int count = ((Integer)limitCount.get(generic)).intValue();
                         if (count > 0)
                         {
                           limitCount.put(generic, Integer.valueOf(--count));
                           if ((Settings.seaHeight > 0) && (y <= Settings.seaHeight))
                           {
                             underWaterBlockCount += ((Integer)Settings.blockValues.get(generic)).intValue();
                             if ((Settings.levelLogging) || (report)) {
                               uwLog.add(md);
                             }
                           }
                           else
                           {
                             blockCount += ((Integer)Settings.blockValues.get(generic)).intValue();
                             if ((Settings.levelLogging) || (report)) {
                               mdLog.add(md);
                             }
                           }
                         }
                         else if ((Settings.levelLogging) || (report))
                         {
                           overflowLog.add(md);
                         }
                       }
                       else if (Settings.blockValues.containsKey(md))
                       {
                         if ((Settings.seaHeight > 0) && (y <= Settings.seaHeight))
                         {
                           underWaterBlockCount += ((Integer)Settings.blockValues.get(md)).intValue();
                           if ((Settings.levelLogging) || (report)) {
                             uwLog.add(md);
                           }
                         }
                         else
                         {
                           blockCount += ((Integer)Settings.blockValues.get(md)).intValue();
                           if ((Settings.levelLogging) || (report)) {
                             mdLog.add(md);
                           }
                         }
                       }
                       else if (Settings.blockValues.containsKey(generic))
                       {
                         if ((Settings.seaHeight > 0) && (y <= Settings.seaHeight))
                         {
                           underWaterBlockCount += ((Integer)Settings.blockValues.get(generic)).intValue();
                           if ((Settings.levelLogging) || (report)) {
                             uwLog.add(md);
                           }
                         }
                         else
                         {
                           blockCount += ((Integer)Settings.blockValues.get(generic)).intValue();
                           if ((Settings.levelLogging) || (report)) {
                             mdLog.add(md);
                           }
                         }
                       }
                       else if ((Settings.levelLogging) || (report))
                       {
                         noCountLog.add(md);
                       }
                     }
                   }
                 }
               }
             }
           }
         }
         blockCount += (underWaterBlockCount * Settings.underWaterMultiplier);
         

         final long score = (blockCount * levelMultiplier - deathHandicap * Settings.deathpenalty) / Settings.levelCost - levelHandicap;
         Multiset<MaterialData> uwCount;
         if ((Settings.levelLogging) || (report))
         {
           uwCount = HashMultiset.create(uwLog);
           Multiset<MaterialData> mdCount = HashMultiset.create(mdLog);
           Multiset<MaterialData> ncCount = HashMultiset.create(noCountLog);
           Multiset<MaterialData> ofCount = HashMultiset.create(overflowLog);
           LevelCalcByChunk.this.reportLines.add("Level Log for island at " + island.getCenter());
           if ((sender instanceof Player)) {
             LevelCalcByChunk.this.reportLines.add("Asker is " + sender.getName() + " (" + ((Player)sender).getUniqueId().toString() + ")");
           } else {
             LevelCalcByChunk.this.reportLines.add("Asker is console");
           }
           LevelCalcByChunk.this.reportLines.add("Target player UUID = " + targetPlayer.toString());
           LevelCalcByChunk.this.reportLines.add("Total block value count = " + String.format("%,d", new Object[] { Long.valueOf(blockCount) }));
           LevelCalcByChunk.this.reportLines.add("Level cost = " + Settings.levelCost);
           LevelCalcByChunk.this.reportLines.add("Level multiplier = " + levelMultiplier + " (Player must be online to get a permission multiplier)");
           LevelCalcByChunk.this.reportLines.add("Schematic level handicap = " + levelHandicap + " (level is reduced by this amount)");
           LevelCalcByChunk.this.reportLines.add("Deaths handicap = " + deathHandicap * Settings.deathpenalty + " (" + deathHandicap + " deaths)");
           LevelCalcByChunk.this.reportLines.add("Level calculated = " + score);
           LevelCalcByChunk.this.reportLines.add("==================================");
           int total = 0;
           if (!uwCount.isEmpty())
           {
             LevelCalcByChunk.this.reportLines.add("Underwater block count (Multiplier = x" + Settings.underWaterMultiplier + ") value");
             LevelCalcByChunk.this.reportLines.add("Total number of underwater blocks = " + String.format("%,d", new Object[] { Integer.valueOf(uwCount.size()) }));
             
             Iterable<Multiset.Entry<MaterialData>> entriesSortedByCount = Multisets.copyHighestCountFirst(uwCount).entrySet();
             Iterator<Multiset.Entry<MaterialData>> it = entriesSortedByCount.iterator();
             while (it.hasNext())
             {
               Multiset.Entry<MaterialData> type = (Multiset.Entry)it.next();
               int value = 0;
               if (Settings.blockValues.containsKey(type)) {
                 value = ((Integer)Settings.blockValues.get(type)).intValue();
               } else if (Settings.blockValues.containsKey(new MaterialData(((MaterialData)type.getElement()).getItemType()))) {
                 value = ((Integer)Settings.blockValues.get(new MaterialData(((MaterialData)type.getElement()).getItemType()))).intValue();
               }
               if (value > 0)
               {
                 LevelCalcByChunk.this.reportLines.add(((MaterialData)type.getElement()).toString() + ":" +
                   String.format("%,d", new Object[] {Integer.valueOf(type.getCount()) }) + " blocks x " + value + " = " + value * type.getCount());
                 total += value * type.getCount();
               }
             }
             LevelCalcByChunk.this.reportLines.add("Subtotal = " + total);
             LevelCalcByChunk.this.reportLines.add("==================================");
           }
           LevelCalcByChunk.this.reportLines.add("Regular block count");
           LevelCalcByChunk.this.reportLines.add("Total number of blocks = " + String.format("%,d", new Object[] { Integer.valueOf(mdCount.size()) }));
           


           Iterable<Multiset.Entry<MaterialData>> entriesSortedByCount = mdCount.entrySet();
           Iterator<Multiset.Entry<MaterialData>> it = entriesSortedByCount.iterator();
           while (it.hasNext())
           {
             Multiset.Entry<MaterialData> type = (Multiset.Entry)it.next();
             int value = 0;
             if (Settings.blockValues.containsKey(type)) {
               value = ((Integer)Settings.blockValues.get(type)).intValue();
             } else if (Settings.blockValues.containsKey(new MaterialData(((MaterialData)type.getElement()).getItemType()))) {
               value = ((Integer)Settings.blockValues.get(new MaterialData(((MaterialData)type.getElement()).getItemType()))).intValue();
             }
             if (value > 0)
             {
               LevelCalcByChunk.this.reportLines.add(((MaterialData)type.getElement()).toString() + ":" +
                 String.format("%,d", new Object[] {Integer.valueOf(type.getCount()) }) + " blocks x " + value + " = " + value * type.getCount());
               total += value * type.getCount();
             }
           }
           LevelCalcByChunk.this.reportLines.add("Total = " + total);
           LevelCalcByChunk.this.reportLines.add("==================================");
           LevelCalcByChunk.this.reportLines.add("Blocks not counted because they exceeded limits: " + String.format("%,d", new Object[] { Integer.valueOf(ofCount.size()) }));
           
           entriesSortedByCount = ofCount.entrySet();
           it = entriesSortedByCount.iterator();
           while (it.hasNext())
           {
             Multiset.Entry<MaterialData> type = (Multiset.Entry)it.next();
             Integer limit = (Integer)Settings.blockLimits.get(type.getElement());
             String explain = ")";
             if (limit == null)
             {
               MaterialData generic = new MaterialData(((MaterialData)type.getElement()).getItemType());
               limit = (Integer)Settings.blockLimits.get(generic);
               explain = " - All types)";
             }
             LevelCalcByChunk.this.reportLines.add(((MaterialData)type.getElement()).toString() + ": " + String.format("%,d", new Object[] { Integer.valueOf(type.getCount()) }) + " blocks (max " + limit + explain);
           }
           LevelCalcByChunk.this.reportLines.add("==================================");
           LevelCalcByChunk.this.reportLines.add("Blocks on island that are not in blockvalues.yml");
           LevelCalcByChunk.this.reportLines.add("Total number = " + String.format("%,d", new Object[] { Integer.valueOf(ncCount.size()) }));
           
           entriesSortedByCount = ncCount.entrySet();
           it = entriesSortedByCount.iterator();
           while (it.hasNext())
           {
             Multiset.Entry<MaterialData> type = (Multiset.Entry)it.next();
             LevelCalcByChunk.this.reportLines.add(((MaterialData)type.getElement()).toString() + ": " + String.format("%,d", new Object[] { Integer.valueOf(type.getCount()) }) + " blocks");
           }
           LevelCalcByChunk.this.reportLines.add("=================================");
         }
         if (out != null)
         {
           for (String line : LevelCalcByChunk.this.reportLines) {
             out.println(line);
           }
           System.out.println("Finished writing level log.");
           out.close();
         }
         long calculatePointsToNextLevel = Settings.levelCost * (score + 1L + levelHandicap) - (blockCount * levelMultiplier - deathHandicap * Settings.deathpenalty);
         if (calculatePointsToNextLevel == 0L) {
           calculatePointsToNextLevel = Settings.levelCost * (score + 2L + levelHandicap) - (blockCount * levelMultiplier - deathHandicap * Settings.deathpenalty);
         }
         long pointsToNextLevel = calculatePointsToNextLevel;
         

         plugin.getServer().getScheduler().runTask(plugin, new Runnable()
         {
           public void run()
           {
             Island island = LevelCalcByChunk.1.this.val$plugin.getGrid().getIsland(LevelCalcByChunk.1.this.val$targetPlayer);
             IslandPreLevelEvent event = new IslandPreLevelEvent(LevelCalcByChunk.1.this.val$targetPlayer, island, score);
             event.setLongPointsToNextLevel(this.val$pointsToNextLevel);
             LevelCalcByChunk.1.this.val$plugin.getServer().getPluginManager().callEvent(event);
             long oldLevel = LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer);
             UUID member;
             if (!event.isCancelled())
             {
               if (oldLevel != event.getLevel())
               {
                 LevelCalcByChunk.1.this.val$plugin.getPlayers().setIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer, event.getLevel());
                 
                 LevelCalcByChunk.1.this.val$plugin.getPlayers().save(LevelCalcByChunk.1.this.val$targetPlayer);
               }
               Iterator localIterator;
               if (LevelCalcByChunk.1.this.val$plugin.getPlayers().inTeam(LevelCalcByChunk.1.this.val$targetPlayer)) {
                 for (localIterator = LevelCalcByChunk.1.this.val$plugin.getPlayers().getMembers(LevelCalcByChunk.1.this.val$targetPlayer).iterator(); localIterator.hasNext();)
                 {
                   member = (UUID)localIterator.next();
                   if (LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(member) != event.getLevel())
                   {
                     LevelCalcByChunk.1.this.val$plugin.getPlayers().setIslandLevel(member, event.getLevel());
                     LevelCalcByChunk.1.this.val$plugin.getPlayers().save(member);
                   }
                 }
               }
               if (LevelCalcByChunk.1.this.val$plugin.getPlayers().inTeam(LevelCalcByChunk.1.this.val$targetPlayer))
               {
                 UUID leader = LevelCalcByChunk.1.this.val$plugin.getPlayers().getTeamLeader(LevelCalcByChunk.1.this.val$targetPlayer);
                 if (leader != null) {
                   TopTen.topTenAddEntry(leader, event.getLongLevel());
                 }
               }
               else
               {
                 TopTen.topTenAddEntry(LevelCalcByChunk.1.this.val$targetPlayer, event.getLongLevel());
               }
             }
             IslandPostLevelEvent event3 = new IslandPostLevelEvent(LevelCalcByChunk.1.this.val$targetPlayer, island, event.getLongLevel(), event.getLongPointsToNextLevel());
             LevelCalcByChunk.1.this.val$plugin.getServer().getPluginManager().callEvent(event3);
             if (!event3.isCancelled()) {
               if (LevelCalcByChunk.1.this.val$sender != null) {
                 if (!(LevelCalcByChunk.1.this.val$sender instanceof Player))
                 {
                   if (!LevelCalcByChunk.1.this.val$report)
                   {
                     Util.sendMessage(LevelCalcByChunk.1.this.val$sender, ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandislandLevelis.replace("[level]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer))));
                   }
                   else
                   {
                     for (String line : LevelCalcByChunk.this.reportLines) {
                       Util.sendMessage(LevelCalcByChunk.1.this.val$sender, line);
                     }
                     Util.sendMessage(LevelCalcByChunk.1.this.val$sender, ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandislandLevelis.replace("[level]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer))));
                     if (event.getLongPointsToNextLevel() >= 0L)
                     {
                       String toNextLevel = ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandrequiredPointsToNextLevel.replace("[points]", String.valueOf(event.getLongPointsToNextLevel()));
                       toNextLevel = toNextLevel.replace("[next]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer) + 1L));
                       Util.sendMessage(LevelCalcByChunk.1.this.val$sender, toNextLevel);
                     }
                   }
                 }
                 else
                 {
                   String message;
                   if (!LevelCalcByChunk.1.this.val$report)
                   {
                     if (LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer) != oldLevel) {
                       LevelCalcByChunk.1.this.val$plugin.getMessages().tellOfflineTeam(LevelCalcByChunk.1.this.val$targetPlayer, ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandislandLevelis.replace("[level]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer))));
                     }
                     if (((LevelCalcByChunk.1.this.val$sender instanceof Player)) && (((Player)LevelCalcByChunk.1.this.val$sender).isOnline()))
                     {
                       message = ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale(((Player)LevelCalcByChunk.1.this.val$sender).getUniqueId()).islandislandLevelis.replace("[level]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer)));
                       if (Settings.deathpenalty != 0) {
                         message = message + " " + LevelCalcByChunk.1.this.val$plugin.myLocale(((Player)LevelCalcByChunk.1.this.val$sender).getUniqueId()).levelDeaths.replace("[number]", String.valueOf(LevelCalcByChunk.1.this.val$deathHandicap));
                       }
                       Util.sendMessage(LevelCalcByChunk.1.this.val$sender, message);
                       if (event.getLongPointsToNextLevel() >= 0L)
                       {
                         String toNextLevel = ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale(((Player)LevelCalcByChunk.1.this.val$sender).getUniqueId()).islandrequiredPointsToNextLevel.replace("[points]", String.valueOf(event.getLongPointsToNextLevel()));
                         toNextLevel = toNextLevel.replace("[next]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer) + 1L));
                         Util.sendMessage(LevelCalcByChunk.1.this.val$sender, toNextLevel);
                       }
                     }
                   }
                   else
                   {
                     if (((Player)LevelCalcByChunk.1.this.val$sender).isOnline()) {
                       for (String line : LevelCalcByChunk.this.reportLines) {
                         Util.sendMessage(LevelCalcByChunk.1.this.val$sender, line);
                       }
                     }
                     Util.sendMessage(LevelCalcByChunk.1.this.val$sender, ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandislandLevelis + " " + ChatColor.WHITE + LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer));
                     if (event.getLongPointsToNextLevel() >= 0L)
                     {
                       String toNextLevel = ChatColor.GREEN + LevelCalcByChunk.1.this.val$plugin.myLocale().islandrequiredPointsToNextLevel.replace("[points]", String.valueOf(event.getLongPointsToNextLevel()));
                       toNextLevel = toNextLevel.replace("[next]", String.valueOf(LevelCalcByChunk.1.this.val$plugin.getPlayers().getIslandLevel(LevelCalcByChunk.1.this.val$targetPlayer) + 1L));
                       Util.sendMessage(LevelCalcByChunk.1.this.val$sender, toNextLevel);
                     }
                   }
                 }
               }
             }
           }
         });
       }
     });
   }
 }
}

(Ten post był ostatnio modyfikowany: 04.12.2017, 21:16 przez HardMCore.)

Zareaguj
Odpowiedz
kubek656
Na vote nie trzeba pluginu. Napisałem skrypt na vote, jak chcesz to ci mogę podesłać.

Zareaguj
Odpowiedz
HardMCore
(09.12.2017, 09:31)kubek656 napisał(a): Na vote  nie trzeba pluginu. Napisałem skrypt na vote, jak chcesz to ci mogę podesłać.

Chyba nie wiesz o jakie vote mi chodzi, miałem na myśli plugin Votifier lub jakikolwiek inny polegający na podwyższaniu serwera w rankingu najlepszych serwerów minecraft na różnych stronach, a gracz dostaje za to nagrodę. Poza tym pluginy zawsze działają lepiej od skryptu.

Zareaguj
Odpowiedz
Toranktto
(03.12.2017, 17:13)HardMCore napisał(a): na własne zakątki graczy potrzebny będzie prawdopodobnie inny plugin typu PreciousStones, jednak jest mały problem - nie znam pluginu, który przeliczałby punkty danego terenu, np. z pluginu PreciousStones, więc nie byłoby żadnej topki, tak jak jest to na reszcie serwerów SkyBlock,

Napisałem podobny plugin na CaveBlock (tylko że pod PlotSquared). Jest on bardzo modularny i wystarczy dodać mu front-end obsługujący PreciousStones, będzie działał bez problemu. ;)

Co do propozycji to wydaję mi się że szybciej znajdziesz rootów na TS3 niż tutaj.

Zareaguj
Odpowiedz
.:Reklama:.




Użytkownicy przeglądający ten wątek:

1 gości