package core.handler;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import core.Bot;
import core.bo.message.InMessage;
import core.bo.message.OutMessage;
import core.bo.message.UserFlag;
import core.bo.message.OutMessage.Flag;
import core.event.AccessEvent;
import core.event.AccessListener;
import core.event.BotStateEvent;
import core.event.BotStateListener;
import core.event.MessageEvent;
import core.event.MessageListener;
import core.handler.info.HandlerInfo;
/**
* Super class for all handlers.
* Each class that wan't to extend AbstractHandler should have two constructors:
* () (standard constructor with no arguments
* - create instance of handler that will be used only retrive handler's info via getHandlerInfo method
* (Bot, Map<String, String>)
* - create fully working instance of handler, that will receive events from given bot and with given options
* Input for handlers are methods from listeners messageReceived and stateChanged,
* but handlers can use set of method that are called by default for bot input.
* Output for handlers are sendXxx method defined in AbstractHandler class
*
*/
public abstract class AbstractHandler implements MessageListener, BotStateListener, AccessListener {
/**
* Parent bot given in constructor
*/
protected Bot c_bot;
/**
* Map with options (optionName -> optionValue)
*/
protected Map<String, String> c_options;
protected void user(String m_user, EnumSet<UserFlag> m_flags, String m_client) {}
/**
* Method that is automatically triggered when user enters channel.
* @param m_user Name of entering user.
* @param m_flags Flag of entering user
* @param m_client Chat client of user.
*/
protected void join(String m_user, EnumSet<UserFlag> m_flags, String m_client){}
/**
* Method that is automatically triggered when user leaves channel.
* @param m_user Name of leaving user.
* @param m_flags Flag of leaving user
*/
protected void leave(String m_user, EnumSet<UserFlag> m_flags){}
/**
* Method that is automatically triggered when user receives whisper message.
* @param m_user Name of user that sent the message.
* @param m_flags Flag of user that sent the message.
* @param m_message Received message.
*/
protected void whisperReceived(String m_user, EnumSet<UserFlag> m_flags, String m_message) {}
/**
* Method that is automatically triggered when user sends whisper message.
* @param m_user Name of user that received the message.
* @param m_flags Flag of user that received the message.
* @param m_message Sent message.
*/
protected void whisperSent(String m_user, EnumSet<UserFlag> m_flags, String m_message){}
/**
* Method that is automatically triggered when any whisper message happends.
* @param m_user Name of user that sent/received the message.
* @param m_flags Flag of user that sent/received the message.
* @param m_message Sent/received message.
*/
protected void whisper(String m_user, EnumSet<UserFlag> m_flags, String m_message){}
/**
* Method that is automatically triggered, when someon talks in channel.
* @param m_user Name of user talking.
* @param m_flags User's flag.
* @param m_message Message that he said.
*/
protected void talk(String m_user, EnumSet<UserFlag> m_flags, String m_message){}
/**
* Method is automatically triggered when an admin says an announcement.
* @param m_message Message of the announcement.
*/
protected void announcement(String m_message){}
/**
* Methos is automatically triggered when channel changes.
* @param m_name Name of new channel.
*/
protected void channelChange(String m_name){}
/**
* Method is automatically triggered when flags of a user change.
* @param m_user Name of user.
* @param m_flags New flags status.
*/
protected void flagChange(String m_user, EnumSet<UserFlag> m_flags){}
/**
* Info message - most of input, that can't fit anywhere else.
* @param m_message Info message.
*/
protected void info(String m_message){}
/**
* Message is automatically triggered when error message is received.
* @param m_message Error message.
*/
protected void error(String m_message){}
/**
* Method that is automatically triggered, when someon talks in channel using /me command.
* @param m_user Name of user talking.
* @param m_flags User's flag.
* @param m_message Message that he said.
*/
protected void emote(String m_user, EnumSet<UserFlag> m_flags, String m_message){}
protected void name(String m_name){}
/**
* Method that is automatically triggered, whenever bot gets any input.
* @param m_input Whole input, not parsed.
*/
protected void defaultParse(InMessage m_input){}
/**
* Create new handler ready to return handler's info
*/
public AbstractHandler() {
}
public void playerAdded(AccessEvent e) {
}
public void playerRemoved(AccessEvent e) {
}
public void playerRenamed(AccessEvent e) {
}
/**
* Create new handler with m_bot parent and empty option map
* @param m_bot
*/
public AbstractHandler(Bot m_bot) {
this(m_bot, new HashMap<String, String>());
}
/**
* Create new handler with given options and m_bot
* @param m_bot Instance of Bot associated with this handler.
* @param m_options Map of options set in bot xml file.
*/
public AbstractHandler(Bot m_bot, Map<String, String> m_options){
c_bot = m_bot;
c_options = m_options;
}
/**
* This function is called, whenever any text is send to server
* By default it does nothing
*/
public void messageSend(MessageEvent l_event) {
}
/**
* This method is called whenever any server messsage is received.
* By default does nothing.
*/
public void serverMessageReceived(MessageEvent e) {
}
/**
* This function is called whenever bot receive any input from server.
* If not overwritten it calls parseIntput method for message text.
*/
public void messageReceived(MessageEvent l_event){
parseMessage((InMessage)l_event.getMessage());
}
/**
* @param m_name Name of option.
* @param m_default Default value, if option not found.
* @return option value if there is value with given m_name, m_default otherwise
*/
protected String getOption(String m_name, String m_default) {
String l_str;
return (l_str = c_options.get(m_name)) == null ? m_default : l_str;
}
/**
*
* @param m_name
* @param m_default
* @return
*/
protected int getIntegerOption(String m_name, int m_default) {
try {
return Integer.parseInt(getOption(m_name, "" + m_default));
} catch(NumberFormatException e) {
return m_default;
}
}
protected long getLongOption(String m_name, long m_default) {
try {
return Long.parseLong(getOption(m_name, "" + m_default));
} catch(NumberFormatException e) {
return m_default;
}
}
protected float getFloatOption(String m_name, float m_default) {
try {
return Float.parseFloat(getOption(m_name, "" + m_default));
} catch(NumberFormatException e) {
return m_default;
}
}
/**
* This function is called whenever bot changes its state.
* Default method does nothing.
*/
public void stateChanged(BotStateEvent e) {}
/**
* This method parses input string and calls: first defaultParse method,
* then appropriate method for given input
* @param m_input Unparsed input.
*/
public void parseMessage(InMessage msg){
defaultParse(msg);
switch (msg.getMessageID()){
case USER: //is here
user(msg.getUser(), msg.getFlag(), msg.getClient());
break;
case JOIN:
join(msg.getUser(), msg.getFlag(), msg.getClient());
break;
case LEAVE:
leave(msg.getUser(), msg.getFlag());
break;
case WHISPER_RECEIVE:
whisper(msg.getUser(), msg.getFlag(), msg.getMessage());
whisperReceived(msg.getUser(), msg.getFlag(), msg.getMessage());
break;
case TALK:
talk(msg.getUser(), msg.getFlag(), msg.getMessage());
break;
case BROADCAST:
announcement(msg.getMessage());
break;
case CHANNEL:
channelChange(msg.getChannel());
break;
case USER_FLAG: //flag change
flagChange(msg.getUser(), msg.getFlag());
break;
case WHISPER_SEND:
whisper(msg.getUser(), msg.getFlag(), msg.getMessage());
whisperSent(msg.getUser(), msg.getFlag(), msg.getMessage());
break;
case INFO:
info(msg.getMessage());
break;
case ERROR:
error(msg.getMessage());
break;
case EMOTE: //emote (/me)
emote(msg.getUser(), msg.getFlag(), msg.getMessage());
case NAME:
name(msg.getMessage());
break;
}
}
/**
* Send message to server with average priority
* @param value Message to send.
*/
public void send (String value) {
c_bot.send(value, "", OutMessage.Priority.AVERAGE, EnumSet.noneOf(Flag.class));
}
/**
* Send message to server at once. This method should be use only by login handler.
* If used by other handlers can break login process or cause message to be lost due to quota
* @param value Message to send.
*/
public void sendAtOnce(String value) {
c_bot.send(value, "", OutMessage.Priority.AT_ONCE, EnumSet.noneOf(Flag.class));
}
/**
* Send message to server with high priority
* @param value Message to send.
*/
public void sendHigh(String value) {
c_bot.send(value, "", OutMessage.Priority.HIGH, EnumSet.noneOf(Flag.class));
}
/**
* Send message to server with low priority
* @param value Message to send.
*/
public void sendLow(String value) {
c_bot.send(value, "", OutMessage.Priority.LOW, EnumSet.noneOf(Flag.class));
}
/**
* All handlers must implement this function and pass basic information about them here
* @return basic info for this handler
*/
public abstract HandlerInfo getHandlerInfo();
}
if u got time and if im not getting on your nervs :P
,than he should be abble to kick/ban and if u can some funn stuf like u did on your tebrbot(the slap command that was mega LOL)
Originally Posted by h4x0rz88
Posting Permissions
Reply With Quote
