Evento Hidden Bastard

[Swarlog]

Código [Seleccionar] Expandir

/* This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * http://www.gnu.org/copyleft/gpl.html
 */

package com.l2jfrozen.gameserver.model.entity.event;



import java.util.Calendar;
import java.util.Collection;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Logger;

import com.l2jfrozen.Config;
import com.l2jfrozen.gameserver.managers.TownManager;
import com.l2jfrozen.gameserver.model.L2Character;
import com.l2jfrozen.gameserver.model.L2World;
import com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance;
import com.l2jfrozen.gameserver.model.zone.L2ZoneType;
import com.l2jfrozen.gameserver.network.clientpackets.Say2;
import com.l2jfrozen.gameserver.network.serverpackets.CreatureSay;
import com.l2jfrozen.gameserver.thread.ThreadPoolManager;
import com.l2jfrozen.util.random.Rnd;

import javolution.util.FastList;

/**
 *
 * @author Elfocrash
 */
public class HiddenBastard
{
   public static FastList<L2PcInstance> _players = new FastList<L2PcInstance>();
       public static State state = State.INACTIVE;
       public static L2PcInstance bastard = null;
       public static L2PcInstance winner = null;
       public static enum State  { INACTIVE,PICKING,SEARCHING }
     protected static final Logger _log = Logger.getLogger(TriviaEventManager.class.getName());

     /** Task for event cycles<br> */
     private Task _task;
     
/**
* New instance only by getInstance()<br>
*/
public HiddenBastard()
{
if (Config.ENABLE_HIDDENBASTARD_EVENT)
{
this.scheduleEventStart();
_log.warning("HiddenBastard: Started.");
}
else
{
_log.warning("HiddenBastard: Engine is Disabled.");
}
}

       public class Task implements Runnable
       {
private long _startTime;
public ScheduledFuture<?> nextRun;

public Task(long startTime)
{
_startTime = startTime;
}

public void setStartTime(long startTime)
{
_startTime = startTime;
}         
          @Override
               public void run()
               {
        int delay = (int) Math.round((_startTime - System.currentTimeMillis()) / 1000.0);
  int nextMsg = 0;
  if (delay > 3600)
  {
  nextMsg = delay - 3600;
  }
  else if (delay > 1800)
  {
  nextMsg = delay - 1800;
  }
  else if (delay > 900)
  {
  nextMsg = delay - 900;
  }
  else if (delay > 600)
  {
  nextMsg = delay - 600;
  }
  else if (delay > 300)
  {
  nextMsg = delay - 300;
  }
  else if (delay > 60)
  {
  nextMsg = delay - 60;
  }
  else if (delay > 5)
  {
  nextMsg = delay - 5;
  }
  else if (delay > 0)
  {
  nextMsg = delay;
  }
  else
  {
                if (state != State.INACTIVE)
                  {
                         return;
                  }
               
                Runner();
  }
 
  if (delay > 0)
  {
  nextRun = ThreadPoolManager.getInstance().scheduleGeneral(this, nextMsg * 1000);
  }
  } 
       }
     
       public void Runner()
       {
   _task.setStartTime(System.currentTimeMillis() + 1000L *10);
   ThreadPoolManager.getInstance().executeTask(_task);
           Announce("Hidden Bastard Event Started. In 20 seconds a random player from Giran will be picked to become the hidden bastard.");
               state = State.PICKING;
               waitSecs(20);
               Announce("The event started! Someone in Giran is the Hidden Bastard. Use .bastard command while targeting a player to check if he is the bastard!");
               Announce("You have 5 minutes to search for him.");
               pickBastard();
               wait(4);
               while(state == State.SEARCHING)
               {
                       Announce("One minute left! Still searching for him!");
                       wait(1);
                       while(state == State.SEARCHING)
                       {
                       Announce("No one found the hidden bastard. And that's just sad. " + bastard + "was the bastard.");
                       bastard.setIsBastard(false);
                       bastard.setIsImobilised(false);
                       clear();
                       this.scheduleEventStart();
                       }
               }
       }
       
   /**
* Starts the event
*/
public void scheduleEventStart()
{
try
{
Calendar currentTime = Calendar.getInstance();
Calendar nextStartTime = null;
Calendar testStartTime = null;
for (String timeOfDay : Config.HIDDENBASTARD_INTERVAL)
{
// Creating a Calendar object from the specified interval value
testStartTime = Calendar.getInstance();
testStartTime.setLenient(true);
String[] splitTimeOfDay = timeOfDay.split(":");
testStartTime.set(Calendar.HOUR_OF_DAY, Integer.parseInt(splitTimeOfDay[0]));
testStartTime.set(Calendar.MINUTE, Integer.parseInt(splitTimeOfDay[1]));
// If the date is in the past, make it the next day (Example: Checking for "1:00", when the time is 23:57.)
if (testStartTime.getTimeInMillis() < currentTime.getTimeInMillis())
{
testStartTime.add(Calendar.DAY_OF_MONTH, 1);
}
// Check for the test date to be the minimum (smallest in the specified list)
if (nextStartTime == null || testStartTime.getTimeInMillis() < nextStartTime.getTimeInMillis())
{
nextStartTime = testStartTime;
}
}
if(nextStartTime != null)
     _task = new Task(nextStartTime.getTimeInMillis());
ThreadPoolManager.getInstance().executeTask(_task);
}
catch (Exception e)
{
_log.warning("TriviaEventEngine[TriviaManager.scheduleEventStart()]: Error figuring out a start time. Check TriviaEventInterval in config file.");
}
}

       public static void Announce(String msg)
       {
               Collection<L2PcInstance> plrs = L2World.getInstance().getAllPlayers();
               CreatureSay cs = new CreatureSay(1, Say2.ANNOUNCEMENT, "", msg);
             
               for (L2PcInstance pls : plrs)
               {
                       pls.sendPacket(cs);
               }
       }
     
     
       public void pickBastard()
       {             
               state = State.SEARCHING;
             
               L2ZoneType zone = TownManager.getInstance().getTown(9);

               for (L2Character character : zone.getCharactersInside().values())
               if ((character instanceof L2PcInstance) && !((L2PcInstance) character).isInCombat() && !((L2PcInstance) character).isInParty() && !((L2PcInstance) character).isInOlympiadMode() && !((L2PcInstance) character).isCursedWeaponEquipped())
               _players.add((L2PcInstance) character);
                                                     
               if(_players.size() > 2)
               {
                bastard = _players.get(Rnd.get(1, _players.size() - 1));
                bastard.setIsBastard(true);
                bastard.sendMessage("You are the secret bastard. You are not allowed to move or talk.");
                bastard.setIsImobilised(true);
               }
               else
               {
                    Announce("Non enough players in giran for the event to start.");
                    state = State.INACTIVE;
                    this.scheduleEventStart();
                    clear();
               }               
        }
     
       public static void endAndReward(L2PcInstance player)
       {
       player.addItem("reward", Config.HIDDENBASTARD_EVENT_REWARD_ID, Config.HIDDENBASTARD_EVENT_REWARD_AMOUNT, player,true);
       }
     
       public static void clear()
       {
               _players.clear();
               bastard = null;
               winner = null;
               state = State.INACTIVE;
       }
       
       public void waitSecs(int i)
       {
               try
               {
                       Thread.sleep(i * 1000);
               }
               catch (InterruptedException ie)
               {
                       ie.printStackTrace();
               }
       }
     
       public void wait(int i)
       {
               try
               {
                       Thread.sleep(i * 60000);
               }
               catch (InterruptedException ie)
               {
                       ie.printStackTrace();
               }
       }
     
       public static HiddenBastard getInstance()
       {
               return SingletonHolder._instance;
       }
     
       private static class SingletonHolder
       {
             protected static final HiddenBastard _instance = new HiddenBastard();
       }
}

Código [Seleccionar] Expandir

/*
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
package com.l2jfrozen.gameserver.handler.voicedcommandhandlers;

import com.l2jfrozen.gameserver.handler.IVoicedCommandHandler;
import com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance;
import com.l2jfrozen.gameserver.model.entity.event.HiddenBastard;

/**
 *
 * @author  Elfocrash
 */

public class HiddenBastardCmd implements IVoicedCommandHandler
{
private static String[] _voicedCommands =
{
"bastard"
};

@Override
public boolean useVoicedCommand(String command, L2PcInstance activeChar, String target)
{
if(command.equalsIgnoreCase(_voicedCommands[0]))
{
if(!(activeChar.getTarget() instanceof L2PcInstance))
{
activeChar.sendMessage("Only players can be bastards.");
return false;
}

if(activeChar.getTarget() == activeChar)
{
activeChar.sendMessage("You are too good to be the bastard.");
return false;
}

if(activeChar.getTarget() == null)
{
activeChar.sendMessage("You have to target someone.");
return false;
}

if(((L2PcInstance) activeChar.getTarget()) == HiddenBastard.bastard)
{
activeChar.sendMessage("You found him!" + activeChar.getTarget().getName() + " is the bastard.");
HiddenBastard.Announce(activeChar.getName() + " found the hidden bastard who was " + HiddenBastard.bastard);
HiddenBastard.endAndReward(activeChar);
HiddenBastard.bastard.setIsBastard(false);
HiddenBastard.bastard.setIsImobilised(false);
HiddenBastard.clear();
}
else
{
activeChar.sendMessage("No! " + activeChar.getTarget().getName() + " is not the bastard.");
return false;
}
}
return true;
}

@Override
public String[] getVoicedCommandList()
{
return _voicedCommands;
}
}