API tools faq
paste
Guest User

Untitled

a guest
Jul 5th, 2013
124
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 42.45 KB | None | 0 0
raw download clone embed print report
  1. package events.Viktorina;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.File;
  6. import java.io.FileReader;
  7. import java.io.FileWriter;
  8. import java.sql.Connection;
  9. import java.sql.PreparedStatement;
  10. import java.sql.ResultSet;
  11. import java.sql.SQLException;
  12. import java.util.ArrayList;
  13. import java.util.Calendar;
  14. import java.util.List;
  15. import java.util.StringTokenizer;
  16. import java.util.concurrent.ScheduledFuture;
  17.  
  18. import l2r.commons.dbutils.DbUtils;
  19. import l2r.commons.util.Rnd;
  20. import l2r.gameserver.Announcements;
  21. import l2r.gameserver.Config;
  22. import l2r.gameserver.ThreadPoolManager;
  23. import l2r.gameserver.database.DatabaseFactory;
  24. import l2r.gameserver.handler.voicecommands.IVoicedCommandHandler;
  25. import l2r.gameserver.handler.voicecommands.VoicedCommandHandler;
  26. import l2r.gameserver.instancemanager.ServerVariables;
  27. import l2r.gameserver.listener.actor.player.OnPlayerEnterListener;
  28. import l2r.gameserver.model.GameObjectsStorage;
  29. import l2r.gameserver.model.Player;
  30. import l2r.gameserver.model.actor.listener.CharListenerList;
  31. import l2r.gameserver.network.serverpackets.Say2;
  32. import l2r.gameserver.network.serverpackets.SystemMessage;
  33. import l2r.gameserver.network.serverpackets.components.ChatType;
  34. import l2r.gameserver.scripts.Functions;
  35. import l2r.gameserver.scripts.ScriptFile;
  36.  
  37. import org.slf4j.Logger;
  38. import org.slf4j.LoggerFactory;
  39.  
  40. import events.EventsConfig;
  41.  
  42. public class Viktorina extends Functions implements ScriptFile, IVoicedCommandHandler, OnPlayerEnterListener
  43. {
  44.         private static final Logger _log = LoggerFactory.getLogger(Viktorina.class);
  45.         private String[] _commandList = new String[] { "o", "voff", "von", "vhelp", "vtop", "v", "vo" };
  46.         private ArrayList<String> questions = new ArrayList<String>();
  47.         private static ArrayList<Player> playerList = new ArrayList<Player>();
  48.         static ScheduledFuture<?> _taskViktorinaStart;
  49.         private static ArrayList<RewardList> _items = new ArrayList<RewardList>();
  50.         static ScheduledFuture<?> _taskStartQuestion;
  51.         static ScheduledFuture<?> _taskStopQuestion;
  52.         long _timeStopViktorina = 0;
  53.         private static boolean status = false;
  54.         private static boolean _questionStatus = false;
  55.         private static int index;
  56.         private static String question;
  57.         private static String answer;
  58.         private final static String GET_LIST_FASTERS = "SELECT `obj_id`,`value` FROM `character_variables` WHERE `name`='viktorinafirst' ORDER BY `value` DESC LIMIT 0,10";
  59.         private final static String GET_LIST_TOP = "SELECT `obj_id`,`value` FROM `character_variables` WHERE `name`='viktorinaschet' ORDER BY `value` DESC LIMIT 0,10";;
  60.         private static Viktorina instance;
  61.         private static boolean DEBUG_VIKROINA = true;
  62.        
  63.         private static List<String> _ipLocker = new ArrayList<String>();
  64.  
  65.  
  66.         public static Viktorina getInstance()
  67.         {
  68.                 if(instance == null)
  69.                         instance = new Viktorina();
  70.                 return instance;
  71.         }
  72.  
  73.         /**
  74.          * Загружаем базу вопросов.
  75.          */
  76.         public void loadQuestions()
  77.         {
  78.                 File file = new File(Config.DATAPACK_ROOT + "/data/other/events/Viktorina/questions.txt");
  79.  
  80.                 try
  81.                 {
  82.                         BufferedReader br = new BufferedReader(new FileReader(file));
  83.                         String str;
  84.                         while((str = br.readLine()) != null)
  85.                         {
  86.                                 questions.add(str);
  87.                         }
  88.                         br.close();
  89.                         _log.info("Viktorina Event: Questions loaded");
  90.                 }
  91.                 catch(Exception e)
  92.                 {
  93.                         _log.info("Viktorina Event: Error parsing questions file. " + e);
  94.                         e.printStackTrace();
  95.                 }
  96.         }
  97.  
  98.         /**
  99.          * Сохраняем вопросы обратно в файл.
  100.          */
  101.         public void saveQuestions()
  102.         {
  103.                 if(!Config.VIKTORINA_REMOVE_QUESTION)
  104.                         return;
  105.                 File file = new File(Config.DATAPACK_ROOT + "/data/other/events/Viktorina/questions.txt");
  106.  
  107.                 try
  108.                 {
  109.                         BufferedWriter br = new BufferedWriter(new FileWriter(file));
  110.                         for(String str : questions)
  111.                                 br.write(str + "\r\n");
  112.                         br.close();
  113.                         _log.info("Viktorina Event: Questions saved");
  114.                 }
  115.                 catch(Exception e)
  116.                 {
  117.                         _log.info("Viktorina Event: Error save questions file. " + e);
  118.                         e.printStackTrace();
  119.                 }
  120.         }
  121.  
  122.         /**
  123.          * Готовим вопрос, вытягиваем рандомно любой вопрос с ответом.
  124.          */
  125.         public void parseQuestion()
  126.         {
  127.                 index = Rnd.get(questions.size());
  128.                 String str = questions.get(index);
  129.                 StringTokenizer st = new StringTokenizer(str, "|");
  130.                 question = st.nextToken();
  131.                 answer = st.nextToken();
  132.         }
  133.  
  134.         public void checkAnswer(String chat, Player player)
  135.         {
  136.                 if(chat.equalsIgnoreCase(answer) && isQuestionStatus())
  137.                 {
  138.                         if(!playerList.contains(player))
  139.                                 playerList.add(player);
  140.                                 _log.info("Viktorina: игрок - " + player.getName() + " дал правильный ответ. Был добавлен в список." );
  141.                 }
  142.         }
  143.  
  144.         /**
  145.          * Анонс вопроса викторины.
  146.          * @param text
  147.          */
  148.         public void announseViktorina(String text)
  149.         {
  150.                 Say2 cs = new Say2(0, ChatType.TELL, "Викторина", text);
  151.                 for(Player player : GameObjectsStorage.getAllPlayersForIterate())
  152.                         if(player.getVar("viktorina") == "on")
  153.                                 player.sendPacket(cs);
  154.         }
  155.  
  156.         public void checkPlayers()
  157.         {
  158.             Say2 cs = new Say2(0, ChatType.TELL, "Викторина", "Что бы участвовать в викторине используйте голосовую команду .von, для справки введите .vhelp");
  159.             for(Player player : GameObjectsStorage.getAllPlayersForIterate())
  160.                 if(player.getVar("viktorina") == null)
  161.                     player.sendPacket(cs);
  162.         }
  163.  
  164.         public void viktorinaSay(Player player, String text)
  165.         {
  166.                 Say2 cs = new Say2(0, ChatType.TELL, "Викторина", text);
  167.                 if(player.getVar("viktorina") == "on")
  168.                         player.sendPacket(cs);
  169.         }
  170.  
  171.         /**
  172.          * Подсчет правильно ответивших
  173.          */
  174.         public void winners()
  175.         {
  176.                 if(!isStatus())
  177.                 {
  178.                         _log.info("Пытался объявить победителя, но викторина оказалась выключена", "Viktorina");
  179.                         return;
  180.                 }
  181.                 if(isQuestionStatus())
  182.                 {
  183.                         _log.info("Пытался объявить победителя, когда действовал вопрос.", "Viktorina");
  184.                         return;
  185.                 }
  186.                 if(ServerVariables.getString("viktorinaq") == null)
  187.                         ServerVariables.set("viktorinaq", 0);
  188.                 if(ServerVariables.getString("viktorinaa") == null)
  189.                         ServerVariables.set("viktorinaa", 0);
  190.                 if(playerList.size() > 0)
  191.                 {
  192.                         announseViktorina(" правильных ответов: " + playerList.size() + ", первый ответил: " + playerList.get(0).getName() + ", правильный ответ: " + answer + "");
  193.                         ServerVariables.set("viktorinaq", ServerVariables.getInt("viktorinaq") + 1);
  194.                         ServerVariables.set("viktorinaa", ServerVariables.getInt("viktorinaa") + 1);
  195.                         if(Config.VIKTORINA_REMOVE_QUESTION)
  196.                                 questions.remove(index);
  197.                         _log.info("" + playerList.get(0).getName() + "|" + playerList.size() + "|" + question + "|" + answer, "Viktorina");
  198.                 }
  199.                 else
  200.                 {
  201.                         if(Config.VIKTORINA_REMOVE_QUESTION_NO_ANSWER)
  202.                                 announseViktorina(" правильного ответа не поступило, правильный ответ был:" + answer + "");
  203.                         if(!Config.VIKTORINA_REMOVE_QUESTION_NO_ANSWER)
  204.                                 announseViktorina(" правильного ответа не поступило");
  205.                         ServerVariables.set("viktorinaq", ServerVariables.getInt("viktorinaq") + 1);
  206.                         if(Config.VIKTORINA_REMOVE_QUESTION && Config.VIKTORINA_REMOVE_QUESTION_NO_ANSWER)
  207.                                 questions.remove(index);
  208.                 }
  209.         }
  210.  
  211.         /**
  212.          * Считам через сколько стартуем викторину, создаем пул.
  213.          */
  214.         public void Start()
  215.         {
  216.                 if(_taskViktorinaStart != null)
  217.                         _taskViktorinaStart.cancel(true);
  218.                 Calendar _timeStartViktorina = Calendar.getInstance();
  219.                 _timeStartViktorina.set(Calendar.HOUR_OF_DAY, Config.VIKTORINA_START_TIME_HOUR);
  220.                 _timeStartViktorina.set(Calendar.MINUTE, Config.VIKTORINA_START_TIME_MIN);
  221.                 _timeStartViktorina.set(Calendar.SECOND, 0);
  222.                 _timeStartViktorina.set(Calendar.MILLISECOND, 0);
  223.                 Calendar _timeStopViktorina = Calendar.getInstance();
  224.                 _timeStopViktorina.setTimeInMillis(_timeStartViktorina.getTimeInMillis());
  225.                 _timeStopViktorina.add(Calendar.HOUR_OF_DAY, Config.VIKTORINA_WORK_TIME);
  226.                 long currentTime = System.currentTimeMillis();
  227.                 // Если время виторины еще не наступило
  228.                 if(_timeStartViktorina.getTimeInMillis() >= currentTime)
  229.                 {
  230.                         _taskViktorinaStart = ThreadPoolManager.getInstance().schedule(new ViktorinaStart(_timeStopViktorina.getTimeInMillis()), _timeStartViktorina.getTimeInMillis() - currentTime);
  231.                 }
  232.                 // Если как раз идет время викторины - стартуем викторину
  233.                 else if(currentTime > _timeStartViktorina.getTimeInMillis() && currentTime < _timeStopViktorina.getTimeInMillis())
  234.                 {
  235.                         _taskViktorinaStart = ThreadPoolManager.getInstance().schedule(new ViktorinaStart(_timeStopViktorina.getTimeInMillis()), 1000);
  236.                 }
  237.                 // сегодня олим уже не должен запускаться, значит нада стартовать викторину
  238.                 // на след день, прибавляем 24 часа
  239.                 else
  240.                 {
  241.                         _timeStartViktorina.add(Calendar.HOUR_OF_DAY, 24);
  242.                         _timeStopViktorina.add(Calendar.HOUR_OF_DAY, 24);
  243.                         _taskViktorinaStart = ThreadPoolManager.getInstance().schedule(new ViktorinaStart(_timeStopViktorina.getTimeInMillis()), _timeStartViktorina.getTimeInMillis() - currentTime);
  244.                 }
  245.  
  246.                 if(DEBUG_VIKROINA)
  247.                         _log.info("Start Viktorina: " + _timeStartViktorina.getTime());
  248.                         _log.info("Stop Viktorina: " + _timeStopViktorina.getTime());
  249.  
  250.         }
  251. /**
  252.  * Функция продолжения таймера викторины, нужна при ручной остановке викторины.
  253.  * Назначает старт викторины на след день
  254.  */
  255.         public void Continue()
  256.         {
  257.                 if(_taskViktorinaStart != null)
  258.                         _taskViktorinaStart.cancel(true);
  259.                 Calendar _timeStartViktorina = Calendar.getInstance();
  260.                 _timeStartViktorina.set(Calendar.HOUR_OF_DAY, Config.VIKTORINA_START_TIME_HOUR);
  261.                 _timeStartViktorina.set(Calendar.MINUTE, Config.VIKTORINA_START_TIME_MIN);
  262.                 _timeStartViktorina.set(Calendar.SECOND, 0);
  263.                 _timeStartViktorina.set(Calendar.MILLISECOND, 0);
  264.                 Calendar _timeStopViktorina = Calendar.getInstance();
  265.                 _timeStopViktorina.setTimeInMillis(_timeStartViktorina.getTimeInMillis());
  266.                 _timeStopViktorina.add(Calendar.HOUR_OF_DAY, Config.VIKTORINA_WORK_TIME);
  267.                 _timeStartViktorina.add(Calendar.HOUR_OF_DAY, 24);
  268.                 _timeStopViktorina.add(Calendar.HOUR_OF_DAY, 24);
  269.                 long currentTime = System.currentTimeMillis();
  270.                 _taskViktorinaStart = ThreadPoolManager.getInstance().schedule(new ViktorinaStart(_timeStopViktorina.getTimeInMillis()), _timeStartViktorina.getTimeInMillis() - currentTime);
  271.                 if(DEBUG_VIKROINA)
  272.                         _log.info("Continue Viktorina: " + _timeStartViktorina.getTime() + "|Stop Viktorina: " + _timeStopViktorina.getTime());
  273.  
  274.         }
  275.         /**
  276.          * Запуск викторины в ручную!!
  277.          * запускается на время указанное в настройках.
  278.          */
  279.         public void ForseStart()
  280.         {
  281.                 if(_taskViktorinaStart != null)
  282.                         _taskViktorinaStart.cancel(true);
  283.                 Calendar _timeStartViktorina = Calendar.getInstance();
  284.                 Calendar _timeStopViktorina = Calendar.getInstance();
  285.                 _timeStopViktorina.setTimeInMillis(_timeStartViktorina.getTimeInMillis());
  286.                 _timeStopViktorina.add(Calendar.HOUR_OF_DAY, Config.VIKTORINA_WORK_TIME);
  287.                 _log.info("Viktorina Started");
  288.                 _taskViktorinaStart = ThreadPoolManager.getInstance().schedule(new ViktorinaStart(_timeStopViktorina.getTimeInMillis()), 1000);
  289.                 if(DEBUG_VIKROINA)
  290.                         _log.info("Start Viktorina: " + _timeStartViktorina.getTime());
  291.                         _log.info("Stop Viktorina: " + _timeStopViktorina.getTime());
  292.  
  293.         }
  294.  
  295.         /**
  296.          * Стартуем викторину
  297.          * @author Sevil
  298.          *
  299.          */
  300.         public class ViktorinaStart implements Runnable
  301.         {
  302.  
  303.                 public ViktorinaStart(long timeStopViktorina)
  304.                 {
  305.                         _timeStopViktorina = timeStopViktorina;
  306.                 }
  307.  
  308.                 public void run()
  309.                 {
  310.                         try
  311.                         {
  312.                                 //if(isStatus())
  313.                                 //{
  314.                                 //      if(DEBUG_VIKROINA)
  315.                                 //              _log.info("Viktoryna is already starter, WTF ??? \n" + Util.dumpStack());
  316.                                 //      return;
  317.                                 //}
  318.                                 if(_taskStartQuestion != null)
  319.                                         _taskStartQuestion.cancel(true);
  320.                                 _taskStartQuestion = ThreadPoolManager.getInstance().schedule(new startQuestion(_timeStopViktorina), 5000);
  321.                                 Announcements.getInstance().announceToAll("Викторина началась!");
  322.                                 Announcements.getInstance().announceToAll("Для справки введите .vhelp");
  323.                                 loadQuestions();
  324.                                 setStatus(true);
  325.  
  326.                         }
  327.                         catch(Exception e)
  328.                         {
  329.                                 e.printStackTrace();
  330.                         }
  331.                 }
  332.         }
  333.  
  334.         /**
  335.          * Задаем вопрос, ждем время, запускаем стоп вопроса.
  336.          * @author Sevil
  337.          *
  338.          */
  339.         public class startQuestion implements Runnable
  340.         {
  341.                 long _timeStopViktorina = 0;
  342.  
  343.                 public startQuestion(long timeStopViktorina)
  344.                 {
  345.                         _timeStopViktorina = timeStopViktorina;
  346.                 }
  347.  
  348.                 public void run()
  349.                 {
  350.                         long currentTime = Calendar.getInstance().getTimeInMillis();
  351.                         if(currentTime > _timeStopViktorina)
  352.                         {
  353.                                 _log.info("Viktorina time off...", "Viktorina");
  354.                                 playerList.clear();
  355.                                 setStatus(false);
  356.                                 setQuestionStatus(false);
  357.                                 announseViktorina("Время работы викторины истекло, Всем участникам приятного времяпрепровождения!");
  358.                                 Announcements.getInstance().announceToAll("Время викторины закончилось.!");
  359.                                 return;
  360.                         }
  361.                         if(!playerList.isEmpty())
  362.                         {
  363.                                 _log.info("Что за чорт??? почему когда я задаю вопрос, лист правильно ответивших не пуст!?!?", "Viktorina");
  364.                                 playerList.clear();
  365.                                 return;
  366.                         }
  367.                         if(!isStatus())
  368.                         {
  369.                                 _log.info("Что за чорт??? Почему я должен задавать вопрос, когда викторина не запущена???", "Viktorina");
  370.                                 return;
  371.                         }
  372.                         if(!isQuestionStatus())
  373.                         {
  374.                                 parseQuestion();
  375.                                 checkPlayers();
  376.                                 announseViktorina(question);
  377.                                 if(_taskStopQuestion != null)
  378.                                         _taskStopQuestion.cancel(true);
  379.                                 _taskStopQuestion = ThreadPoolManager.getInstance().schedule(new stopQuestion(_timeStopViktorina), Config.VIKTORINA_TIME_ANSER * 1000);
  380.                                 setQuestionStatus(true);
  381.                         }
  382.                         else
  383.                         {
  384.                                 _log.info("Что за чорт???? ПОчему статус вопроса true?? когда быть должен false!!!!", "Viktorina");
  385.                         }
  386.                 }
  387.         }
  388.  
  389.         /**
  390.          * Стоп вопроса: подсчитываем правильные ответы, и кто дал правильный ответ быстрее всех.
  391.          * запускаем следующий вопрос.
  392.          * @author Sevil
  393.          *
  394.          */
  395.         public class stopQuestion implements Runnable
  396.         {
  397.                 long _timeStopViktorina = 0;
  398.  
  399.                 public stopQuestion(long timeStopViktorina)
  400.                 {
  401.                         _timeStopViktorina = timeStopViktorina;
  402.                 }
  403.  
  404.                 public void run()
  405.                 {
  406.                         if(!isStatus())
  407.                         {
  408.                                 _log.info("Что за чорт??? Почему я должен считать победителей и выдавать награды когда викторина не запущена???", "Viktorina");
  409.                                 return;
  410.                         }
  411.                         setQuestionStatus(false);
  412.                         winners();
  413.                         rewarding();
  414.                         playerList.clear();
  415.                         if(_taskStartQuestion != null)
  416.                                 _taskStartQuestion.cancel(true);
  417.                         _taskStartQuestion = ThreadPoolManager.getInstance().schedule(new startQuestion(_timeStopViktorina), Config.VIKTORINA_TIME_PAUSE * 1000);
  418.                 }
  419.         }
  420.  
  421.         /**
  422.          * Останавливаем эвент.
  423.          */
  424.         public void stop()
  425.         {
  426.                 playerList.clear();
  427.                 if(_taskStartQuestion != null)
  428.                         _taskStartQuestion.cancel(true);
  429.                 if(_taskStopQuestion != null)
  430.                         _taskStopQuestion.cancel(true);
  431.                 setQuestionStatus(false);
  432.                 _log.info("Viktorina Stoped.", "Viktorina");
  433.                 if(isStatus())
  434.                         Announcements.getInstance().announceToAll("Викторина остановлена!");
  435.                 setStatus(false);
  436.                 Continue();
  437.         }
  438.  
  439.         /**
  440.          * Формируем окно справки. вызывается если игрок не разу не учавствовал в викторине
  441.          * или командой .vhelp
  442.          * @param player
  443.          */
  444.         public void help(Player player)
  445.         {
  446.                 int schet;
  447.                 int first;
  448.                 int vq;
  449.                 int va;
  450.                 String vstatus;
  451.                 if(player.getVar("viktorinaschet") == null)
  452.                         schet = 0;
  453.                 else
  454.                         schet = Integer.parseInt(player.getVar("viktorinaschet"));
  455.  
  456.                 if(player.getVar("viktorinafirst") == null)
  457.                         first = 0;
  458.                 else
  459.                         first = Integer.parseInt(player.getVar("viktorinafirst"));
  460.  
  461.                 if(ServerVariables.getString("viktorinaq", "0") == "0")
  462.                 {
  463.                         ServerVariables.set("viktorinaq", 0);
  464.                         vq = 0;
  465.                 }
  466.                 else
  467.                         vq = Integer.parseInt(ServerVariables.getString("viktorinaq"));
  468.  
  469.                 if(ServerVariables.getString("viktorinaa", "0") == "0")
  470.                 {
  471.                         ServerVariables.set("viktorinaa", 0);
  472.                         va = 0;
  473.                 }
  474.                 else
  475.                         va = Integer.parseInt(ServerVariables.getString("viktorinaa"));
  476.                
  477.                 if(player.getVar("viktorina") == "on")
  478.                         vstatus = "<font color=\"#00FF00\">Вы учавствуете в \"Викторине\"</font><br>";
  479.                 else
  480.                         vstatus = "<font color=\"#FF0000\">Вы не учавствуете в \"Викторине\"</font><br>";
  481.                
  482.                 StringBuffer help = new StringBuffer("<html><body>");
  483.                 help.append("<center>Помошь по Викторине<br></center>");
  484.                 help.append(vstatus);
  485.                 help.append("Время начала викторины: " + Config.VIKTORINA_START_TIME_HOUR + ":" + Config.VIKTORINA_START_TIME_MIN + "<br>");
  486.                 help.append("Длительность работы викторины " + Config.VIKTORINA_WORK_TIME + " ч.<br>");
  487.                 help.append("Время в течении которого можно дать ответ: " + Config.VIKTORINA_TIME_ANSER + " сек.<br>");
  488.                 help.append("Время между вопросами: " + (Config.VIKTORINA_TIME_ANSER + Config.VIKTORINA_TIME_PAUSE) + " сек.<br>");
  489.                 help.append("Вопросов уже было заданно: " + vq + ".<br>");
  490.                 help.append("Верно ответили на : " + va + ".<br>");
  491.                 help.append("Вы верно ответили на : " + schet + ", в " + first + " вы были первым.<br>");
  492.                 help.append("<br>");
  493.                 help.append("<center>Команды викторины:<br></center>");
  494.                 help.append("<font color=\"LEVEL\">Ответ</font> - вводится в любой вид чата.<br>");
  495.                 help.append("<font color=\"LEVEL\">.von</font> - команда для включения витокрины<br>");
  496.                 help.append("<font color=\"LEVEL\">.voff</font> - команда для выключения витокрины<br>");
  497.                 help.append("<font color=\"LEVEL\">.vtop</font> - команда для просмотра результатов.<br>");
  498.                 help.append("<font color=\"LEVEL\">.vhelp</font> - команда для вызова этой страницы.<br>");
  499.                 help.append("<font color=\"LEVEL\">.v</font> - показывает текущий вопрос.<br>");
  500.                 help.append("</body></html>");
  501.                 show(help.toString(), player);
  502.         }
  503.  
  504.         /**
  505.          * выводит топ
  506.          * @param player
  507.          */
  508.         public void top(Player player)
  509.         {
  510.                 StringBuffer top = new StringBuffer("<html><body>");
  511.                 top.append("<center>Топ Самых Быстрых");
  512.                 top.append("<img src=\"L2UI.SquareWhite\" width=270 height=1><img src=\"L2UI.SquareBlank\" width=1 height=3>");
  513.                 final List<Scores> fasters = getList(true);
  514.                 if(fasters.size() != 0)
  515.                 {
  516.                         top.append("<table width=300 border=0 bgcolor=\"000000\">");
  517.  
  518.                         int index = 1;
  519.  
  520.                         for(final Scores faster : fasters)
  521.                         {
  522.                                 top.append("<tr>");
  523.                                 top.append("<td><center>" + index + "<center></td>");
  524.                                 top.append("<td><center>" + faster.getName() + "<center></td>");
  525.                                 top.append("<td><center>" + faster.getScore() + "<center></td>");
  526.                                 top.append("</tr>");
  527.                                 index++;
  528.                         }
  529.  
  530.                         top.append("<tr><td><br></td><td></td></tr>");
  531.  
  532.                         top.append("</table>");
  533.                 }
  534.                 top.append("<img src=\"L2UI.SquareWhite\" width=270 height=1> <img src=\"L2UI.SquareBlank\" width=1 height=3>");
  535.                 top.append("</center>");
  536.  
  537.                 top.append("<center>Общий топ");
  538.                 top.append("<img src=\"L2UI.SquareWhite\" width=270 height=1><img src=\"L2UI.SquareBlank\" width=1 height=3>");
  539.                 final List<Scores> top10 = getList(false);
  540.                 if(top10.size() != 0)
  541.                 {
  542.                         top.append("<table width=300 border=0 bgcolor=\"000000\">");
  543.  
  544.                         int index = 1;
  545.  
  546.                         for(final Scores top1 : top10)
  547.                         {
  548.                                 top.append("<tr>");
  549.                                 top.append("<td><center>" + index + "<center></td>");
  550.                                 top.append("<td><center>" + top1.getName() + "<center></td>");
  551.                                 top.append("<td><center>" + top1.getScore() + "<center></td>");
  552.                                 top.append("</tr>");
  553.                                 index++;
  554.                         }
  555.  
  556.                         top.append("<tr><td><br></td><td></td></tr>");
  557.  
  558.                         top.append("</table>");
  559.                 }
  560.                 top.append("<img src=\"L2UI.SquareWhite\" width=270 height=1> <img src=\"L2UI.SquareBlank\" width=1 height=3>");
  561.                 top.append("</center>");
  562.  
  563.                 top.append("</body></html>");
  564.                 show(top.toString(), player);
  565.         }
  566.  
  567.         public void setQuestionStatus(boolean b)
  568.         {
  569.                 _questionStatus = b;
  570.         }
  571.  
  572.         public boolean isQuestionStatus()
  573.         {
  574.                 return _questionStatus;
  575.         }
  576.  
  577.         @Override
  578.         public void onLoad()
  579.         {
  580.                 CharListenerList.addGlobal(this);
  581.                 executeTask("events.Viktorina.Viktorina", "preLoad", new Object[0], 20000);
  582.                 VoicedCommandHandler.getInstance().registerVoicedCommandHandler(this);
  583.                 _log.info("Loaded Event: Viktorina");
  584.         }
  585.  
  586.         @Override
  587.         public void onReload()
  588.         {
  589.                 stop();
  590.         }
  591.  
  592.         @Override
  593.         public void onShutdown()
  594.         {
  595.                 stop();
  596.  
  597.         }
  598.  
  599.         @Override
  600.         public String[] getVoicedCommandList()
  601.         {
  602.                 return _commandList;
  603.         }
  604.  
  605.         @Override
  606.         public boolean useVoicedCommand(String command, Player player, String args)
  607.         {
  608.  
  609.                 if(command.equals("o"))
  610.                 {
  611.                         if(args.equalsIgnoreCase(answer) && isQuestionStatus())
  612.                         {
  613.                                 if(!playerList.contains(player))
  614.                                         playerList.add(player);
  615.                                 //_log.info("preprepls " + playerList + "");
  616.                         }
  617.                         if(!isQuestionStatus())
  618.                                 viktorinaSay(player, "Возможно вопрос не был задан,или же время ответа истекло");
  619.                 }
  620.                 if(command.equals("von"))
  621.                 {
  622.                     if(_ipLocker.contains(player.getIP()))
  623.                     {
  624.                         player.sendMessage("Представитель вашего IP адреса уже участвует в Викторине, ваш IP адрес " + player.getIP());
  625.                         return;
  626.                     }
  627.                         player.setVar("viktorina", "on", -1);
  628.                         player.sendMessage("Вы принимаете участие в Викторине!");
  629.                         player.sendMessage("Ждите поступления Вам вопроса в ПМ!");
  630.                         _ipLocker.add(player.getIP());
  631.                 }
  632.                 if(command.equals("voff"))
  633.                 {
  634.                        
  635.                         player.setVar("viktorina", "off", -1);
  636.                         player.sendMessage("Отказались от участия в Викторине!");
  637.                         player.sendMessage("До новых встреч!");
  638.                         _ipLocker.remove(player.getIP());
  639.                 }
  640.                 if(command.equals("vhelp"))
  641.                 {
  642.                         help(player);
  643.                 }
  644.                 if(command.equals("vtop"))
  645.                 {
  646.                         top(player);
  647.                 }
  648.                 if(command.equals("v"))
  649.                 {
  650.                         viktorinaSay(player, question);
  651.                 }
  652.                 if(command.equals("vo") && player.isGM())
  653.                 {
  654.                         viktorinaSay(player, answer);
  655.                 }
  656.                 return true;
  657.         }
  658.  
  659.         /**
  660.          *выдача награды, начисление очков.
  661.          */
  662.         private void rewarding()
  663.         {
  664.                 if(!isStatus())
  665.                 {
  666.                         _log.info("Пытался вручить награды, но викторина оказалась выключена");
  667.                         return;
  668.                 }
  669.                 if(isQuestionStatus())
  670.                 {
  671.                         _log.info("Пытался вручить награды, когда действовал вопрос.");
  672.                         return;
  673.                 }
  674.                
  675.                 parseReward();
  676.                 int schet;
  677.                 int first;
  678.                 for(Player player : playerList)
  679.                 {
  680.                         if(player.getVar("viktorinaschet") == null)
  681.                                 schet = 0;
  682.                         else
  683.                                 schet = Integer.parseInt(player.getVar("viktorinaschet"));
  684.                         if(player.getVar("viktorinafirst") == null)
  685.                                 first = 0;
  686.                         else
  687.                                 first = Integer.parseInt(player.getVar("viktorinafirst"));
  688.                         if(player == playerList.get(0))
  689.                         {
  690.                                 giveItemByChance(player, true);
  691.                                 player.setVar("viktorinafirst", "" + (first + 1) + "", -1);
  692.                         }
  693.                         else
  694.                                 giveItemByChance(player, false);
  695.                         player.setVar("viktorinaschet", "" + (schet + 1) + "", -1);
  696.                 }
  697.         }
  698.  
  699.         /**
  700.          * парсим конфиг наград
  701.          */
  702.         private void parseReward()
  703.         {
  704.                 _items.clear();
  705.                 StringTokenizer st = new StringTokenizer(EventsConfig.get("Victorina_Reward_Ferst"), ";");
  706.                 StringTokenizer str = new StringTokenizer(EventsConfig.get("Victorina_Reward_Other"), ";");
  707.                 while(st.hasMoreTokens())
  708.                 {
  709.                         String str1 = st.nextToken();
  710.                         StringTokenizer str2 = new StringTokenizer(str1, ",");
  711.                         final int itemId = Integer.parseInt(str2.nextToken());
  712.                         final int count = Integer.parseInt(str2.nextToken());
  713.                         final int chance = Integer.parseInt(str2.nextToken());
  714.                         final boolean first = true;
  715.                         final RewardList item = new RewardList();
  716.                         item.setProductId(itemId);
  717.                         item.setCount(count);
  718.                         item.setChance(chance);
  719.                         item.setFirst(first);
  720.                         _items.add(item);
  721.                 }
  722.                 while(str.hasMoreTokens())
  723.                 {
  724.                         String str1 = str.nextToken();
  725.                         StringTokenizer str2 = new StringTokenizer(str1, ",");
  726.                         final int itemId = Integer.parseInt(str2.nextToken());
  727.                         final int count = Integer.parseInt(str2.nextToken());
  728.                         final int chance = Integer.parseInt(str2.nextToken());
  729.                         final boolean first = false;
  730.                         final RewardList item = new RewardList();
  731.                         item.setProductId(itemId);
  732.                         item.setCount(count);
  733.                         item.setChance(chance);
  734.                         item.setFirst(first);
  735.                         _items.add(item);
  736.                 }
  737.         }
  738.  
  739.         /**
  740.          * Выдаем приз на каторую укажет шанс + определяем выдавать приз для первого или для остальных
  741.          * @param player
  742.          * @param first
  743.          * @return
  744.          */
  745.         private boolean giveItemByChance(Player player, boolean first)
  746.         {
  747.                 int chancesumm = 0;
  748.                 int productId = 0;
  749.                 int chance = Rnd.get(0, 100);
  750.                 int count = 0;
  751.                 for(RewardList items : _items)
  752.                 {
  753.                         chancesumm = chancesumm + items.getChance();
  754.                         if(first == items.getFirst() && chancesumm > chance)
  755.                         {
  756.                                 productId = items.getProductId();
  757.                                 count = items.getCount();
  758.                                 addItem(player, productId, count, false);
  759.                                 if(count > 1)
  760.                                         player.sendPacket(new SystemMessage(SystemMessage.YOU_HAVE_EARNED_S2_S1S).addItemName(productId).addNumber(count));
  761.                                 else
  762.                                         player.sendPacket(new SystemMessage(SystemMessage.YOU_HAVE_EARNED_S1).addItemName(productId));
  763.                                 if(DEBUG_VIKROINA)
  764.                                         _log.info("Игрок: " + player.getName() + " получил " + productId + ":" + count + " с шансом: " + items.getChance() + ":" + items.getFirst() + "", "Viktorina");
  765.                                 return true;
  766.                         }
  767.                 }
  768.                 return true;
  769.         }
  770.  
  771.         private class RewardList
  772.         {
  773.                 public int _productId;
  774.                 public int _count;
  775.                 public int _chance;
  776.                 public boolean _first;
  777.  
  778.                 private void setProductId(int productId)
  779.                 {
  780.                         _productId = productId;
  781.                 }
  782.  
  783.                 private void setChance(int chance)
  784.                 {
  785.                         _chance = chance;
  786.                 }
  787.  
  788.                 private void setCount(int count)
  789.                 {
  790.                         _count = count;
  791.                 }
  792.  
  793.                 private void setFirst(boolean first)
  794.                 {
  795.                         _first = first;
  796.                 }
  797.  
  798.                 private int getProductId()
  799.                 {
  800.                         return _productId;
  801.                 }
  802.  
  803.                 private int getChance()
  804.                 {
  805.                         return _chance;
  806.                 }
  807.  
  808.                 private int getCount()
  809.                 {
  810.                         return _count;
  811.                 }
  812.  
  813.                 private boolean getFirst()
  814.                 {
  815.                         return _first;
  816.                 }
  817.         }
  818.  
  819.         private boolean isStatus()
  820.         {
  821.                 return status;
  822.         }
  823.  
  824.         public static boolean isRunned()
  825.         {
  826.                 return status;
  827.         }
  828.  
  829.         @SuppressWarnings("static-access")
  830.         private void setStatus(boolean status)
  831.         {
  832.                 this.status = status;
  833.         }
  834.  
  835.         /**
  836.          * Возвращаем имя чара по его obj_Id
  837.          * @param char_id
  838.          * @return
  839.          */
  840.         private String getName(int char_id)
  841.         {
  842.                 String name = null;
  843.                 Connection con = null;
  844.                 PreparedStatement statement = null;
  845.                 ResultSet rset = null;
  846.  
  847.                 try
  848.                 {
  849.                         con = DatabaseFactory.getInstance().getConnection();
  850.                         statement = con.prepareStatement("SELECT char_name FROM characters WHERE obj_Id=?");
  851.                         statement.setInt(1, char_id);
  852.                         rset = statement.executeQuery();
  853.                         rset.next();
  854.                         name = rset.getString("char_name");
  855.                         //return name;
  856.                 }
  857.                 catch(final SQLException e)
  858.                 {
  859.                         _log.info("ААА!!! ОПАСНОСТЬ, не могу найти игрока с таким obj_Id:" + e.getMessage());
  860.                 }
  861.                 finally
  862.                 {
  863.                         DbUtils.closeQuietly(con, statement, rset);
  864.                 }
  865.                 return name;
  866.         }
  867.  
  868.         /**
  869.          * Возвращаем лист имен.
  870.          * @param first
  871.          * @return
  872.          */
  873.         private List<Scores> getList(final boolean first)
  874.         {
  875.                 final List<Scores> names = new ArrayList<Scores>();
  876.  
  877.                 Connection con = null;
  878.                 PreparedStatement statement = null;
  879.                 ResultSet rset = null;
  880.  
  881.                 String GET_LIST = null;
  882.                 if(first)
  883.                         GET_LIST = GET_LIST_FASTERS;
  884.                 else
  885.                         GET_LIST = GET_LIST_TOP;
  886.  
  887.                 try
  888.                 {
  889.                         con = DatabaseFactory.getInstance().getConnection();
  890.                         statement = con.prepareStatement(GET_LIST);
  891.                         rset = statement.executeQuery();
  892.  
  893.                         while(rset.next())
  894.                         {
  895.                                 final String name = (getName(rset.getInt("obj_id")));
  896.                                 final int score = rset.getInt("value");
  897.                                 Scores scores = new Scores();
  898.                                 scores.setName(name);
  899.                                 scores.setScore(score);
  900.                                 names.add(scores);
  901.                         }
  902.                         return names;
  903.                 }
  904.                 catch(final SQLException e)
  905.                 {
  906.                         e.printStackTrace();
  907.                 }
  908.                 finally
  909.                 {
  910.                         DbUtils.closeQuietly(con, statement, rset);
  911.                 }
  912.  
  913.                 return names;
  914.         }
  915.  
  916.         private class Scores
  917.         {
  918.                 public String _name;
  919.                 public int _score;
  920.  
  921.                 private void setName(String name)
  922.                 {
  923.                         _name = name;
  924.                 }
  925.  
  926.                 private void setScore(int score)
  927.                 {
  928.                         _score = score;
  929.                 }
  930.  
  931.                 private String getName()
  932.                 {
  933.                         return _name;
  934.                 }
  935.  
  936.                 private int getScore()
  937.                 {
  938.                         return _score;
  939.                 }
  940.         }
  941.  
  942.         public static void preLoad()
  943.         {
  944.  
  945.                 if(Config.VIKTORINA_ENABLED)
  946.                         executeTask("events.Viktorina.Viktorina", "Start", new Object[0], 5000);
  947.         }
  948.  
  949.         @Override
  950.         public void onPlayerEnter(Player player)
  951.         {
  952.                 Say2 cs = new Say2(0, ChatType.CRITICAL_ANNOUNCE, "Викторина", "Активен ивент Викторина! Для участия наберите команду .von! Для справки .vhelp!");
  953.                 if(isStatus())
  954.                         player.sendPacket(cs);
  955.         }
  956. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!