public override void Init (){
base.Init ();
if (Instance == null) {
Instance = this;
}
}
public static void Save(string[] args, WorldClass session)
{
ObjectMgr.SavePositionToDB(session.Character);
ChatMessageValues chatMessage = new ChatMessageValues(0, "Your character is successfully saved to the database!");
ChatHandler.SendMessage(ref session, chatMessage);
}
void Start()
{
ftString = initialFollowerText.text;
char[] delimitingChars = {'\n'};
ftLines = ftString.Split (delimitingChars);
ch = chatHandlerObj.GetComponent<ChatHandler> ();
wani = waterAniObj.GetComponent<WaterAnimation> ();
}
//SCRIPTINPUT (FS)
public ChatModule(ChatHandler par, IMyTextPanel panel, int number)
{
parent = par;
window = panel;
ID = number;
InitWindow();
window.CustomData = "";
}
private void _ws_OnTextMessageReceived(object s, MessageEventArgs e)
{
//Plugin.Log($"incoming WS data: {e.Data}");
JSONObject reply = new JSONObject();
Plugin.Log($"RequestUI Request: {e.Data}");
BeatsaberRequestUIMessage bmsg = JsonConvert.DeserializeObject <BeatsaberRequestUIMessage>(e.Data);
ChatUser usr = new ChatUser(bmsg.UserId, bmsg.UserDisplayname, bmsg.UserDisplayname, bmsg.UserRole == "Broadcaster", bmsg.UserRole == "Moderator", "#FFFFFF", null, bmsg.IsSubscriber, false, bmsg.UserRole == "VIP");
string Event = "";
string data = "";
reply.Add("Slug", new JSONString(bmsg.Slug));
reply.Add("Error", null);
switch (bmsg.Event)
{
case "Self":
_self = usr;
reply.Add("Event", new JSONString("SelfReply"));
reply.Add("Data", null);
Plugin.Log($"Received userdata");
break;
case "List":
reply.Add("Event", new JSONString("ListReply"));
var arr = new JSONArray();
foreach (var request in RequestQueue.Songs)
{
arr.Add(request.song["id"]);
}
reply.Add("Data", arr);
break;
case "Undo":
ChatHandler.ParseMessage(usr, "!oops");
reply.Add("Event", new JSONString("UndoReply"));
reply.Add("Data", null);
break;
case "Pair":
reply.Add("Event", new JSONString("PairReply"));
reply.Add("Data", null);
break;
case "Request":
default:
AutoResetEvent callback = new AutoResetEvent(false);
Func <bool> action = callback.Set;
ChatHandler.ParseMessage(usr, "!bsr " + bmsg.Data, action);
callback.WaitOne();
reply.Add("Event", new JSONString("RequestReply"));
reply.Add("Data", new JSONBool(RequestQueue.Songs.Any(r => r.song["id"] == bmsg.Data)));
//Plugin.Log($"Received command: {msg.Message}");
break;
}
Plugin.Log($"RequestUI Reply: {reply.ToString()}");
_ws.Send(reply.ToString());
}
public static void Teleport(string[] args, WorldClass session)
{
var pChar = session.Character;
Vector4 vector;
uint mapId;
if (args.Length > 2)
{
vector = new Vector4()
{
X = CommandParser.Read <float>(args, 1),
Y = CommandParser.Read <float>(args, 2),
Z = CommandParser.Read <float>(args, 3),
O = CommandParser.Read <float>(args, 4)
};
mapId = CommandParser.Read <uint>(args, 5);
}
else
{
string location = CommandParser.Read <string>(args, 1);
SQLResult result = DB.World.Select("SELECT * FROM teleport_locations WHERE location = ?", location);
if (result.Count == 0)
{
ChatMessageValues chatMessage = new ChatMessageValues(0, "Teleport location '" + location + "' does not exist.");
ChatHandler.SendMessage(ref session, chatMessage);
return;
}
vector = new Vector4()
{
X = result.Read <float>(0, "X"),
Y = result.Read <float>(0, "Y"),
Z = result.Read <float>(0, "Z"),
O = result.Read <float>(0, "O")
};
mapId = result.Read <uint>(0, "Map");
}
if (pChar.Map == mapId)
{
MoveHandler.HandleMoveTeleport(ref session, vector);
ObjectMgr.SetPosition(ref pChar, vector);
}
else
{
MoveHandler.HandleTransferPending(ref session, mapId);
MoveHandler.HandleNewWorld(ref session, vector, mapId);
ObjectMgr.SetPosition(ref pChar, vector);
ObjectMgr.SetMap(ref pChar, mapId);
ObjectHandler.HandleUpdateObjectCreate(ref session);
}
}
public BlManager()
{
bluetoothAdapter = BluetoothAdapter.DefaultAdapter;
receiver = new DiscoverableModeReceiver();
receiver.BluetoothDiscoveryModeChanged += (sender, e) =>
{
};
handler = new ChatHandler();
}
public static bool HandleModifyMoneyCommand(string[] args, CommandGroup handler)
{
if (args.Count() < 1)
return false;
Player target = handler.getSelectedPlayer();
if (target == null)
return handler.SendErrorMessage(CypherStrings.NoCharSelected);
// check online security
if (handler.HasLowerSecurity(target, 0))
return false;
long addmoney;
long.TryParse(args[0], out addmoney);
long moneyuser = (long)target.GetMoney();
if (addmoney < 0)
{
ulong newmoney = (ulong)(moneyuser + addmoney);
Log.outDebug(ObjMgr.GetCypherString(CypherStrings.CurrentMoney), moneyuser, addmoney, newmoney);
if (newmoney <= 0)
{
handler.SendSysMessage(CypherStrings.YouTakeAllMoney, handler.GetNameLink(target));
if (handler.needReportToTarget(target))
ChatHandler.SendSysMessage(target, CypherStrings.YoursAllMoneyGone, handler.GetNameLink());
target.SetMoney(0);
}
else
{
if (newmoney > PlayerConst.MaxMoneyAmount)
newmoney = PlayerConst.MaxMoneyAmount;
handler.SendSysMessage(CypherStrings.YouTakeMoney, Math.Abs(addmoney), handler.GetNameLink(target));
if (handler.needReportToTarget(target))
ChatHandler.SendSysMessage(target, CypherStrings.YoursMoneyTaken, handler.GetNameLink(), Math.Abs(addmoney));
target.SetMoney(newmoney);
}
}
else
{
handler.SendSysMessage( CypherStrings.YouGiveMoney, addmoney, handler.GetNameLink(target));
if (handler.needReportToTarget(target))
ChatHandler.SendSysMessage(target, CypherStrings.YoursMoneyGiven, handler.GetNameLink(), addmoney);
if (addmoney >= PlayerConst.MaxMoneyAmount)
target.SetMoney(PlayerConst.MaxMoneyAmount);
else
target.ModifyMoney(addmoney);
}
Log.outDebug(ObjMgr.GetCypherString(CypherStrings.NewMoney), moneyuser, addmoney, target.GetMoney());
return true;
}
public override void Init()
{
base.Init();
if (Instance == null)
{
Instance = this;
}
}
public bool isInPlayerMap; // for checking if the player is using the full map or the player map
private void Awake()
{
infoObject = GameObject.FindObjectOfType <InfoObject>();
logHandler = GameObject.FindObjectOfType <LogHandler>();
chatHandler = GameObject.FindObjectOfType <ChatHandler>();
timerController = GameObject.FindObjectOfType <TimerController>();
gameData = GameObject.FindObjectOfType <GameData>();
isInPlayerMap = true;
}
public static void GPS(string[] args)
{
var session = WorldMgr.Session;
var pChar = session.Character;
var message = String.Format("Your position is X: {0}, Y: {1}, Z: {2}, W(O): {3}, Map: {4}", pChar.X, pChar.Y, pChar.Z, pChar.O, pChar.Map);
ChatHandler.SendMessageByType(ref session, 0, 0, message);
}
public static void GPS(string[] args, WorldClass session)
{
var pChar = session.Character;
var message = string.Format("Your position is X: {0}, Y: {1}, Z: {2}, W(O): {3}, Map: {4}, Zone: {5}", pChar.Position.X, pChar.Position.Y, pChar.Position.Z, pChar.Position.O, pChar.Map, pChar.Zone);
ChatMessageValues chatMessage = new ChatMessageValues(0, message);
ChatHandler.SendMessage(ref session, chatMessage);
}
private void UpdateInternalMessageList()
{
chatMessages = new string[chatQueue.Count];
object[] msgs = chatQueue.ToArray();
for (int i = 0; i < chatQueue.Count; i++)
{
chatMessages[i] = ChatHandler.ChatMessageToString((ChatMessage)msgs[i]);
}
}
private void LoadExtensionsCommand(string[] files)
{
foreach (var ext in files)
{
Server.ExtensionManager.LoadExtension(ext);
ChatHandler.SendMessage("[Server] Loaded extension: " + new FileInfo(ext).Name,
Server.Administrators.ToArray());
}
}
public void OnSave(SvManager svManager)
{
ChatHandler.SendToAll("Saving server status..");
foreach (ShPlayer player in EntityCollections.Humans)
{
player.svPlayer.Save();
}
svManager.database.WriteOut();
}
public GameServer GetHandlers()
{
try
{
GameServer server = (GameServer)GameState.ActiveState;
if (server == null)
{
return(null);
}
mainLog.Info("IRSE: Loaded GameServer Instance!");
ControllerManager = server.Controllers;
var universe = ControllerManager.Universe as Game.Server.UniverseController;
mainLog.Info("IRSE: Waiting for Universe To Populate..");
while (!universe.IsInitialized)
{
Thread.Sleep(1000);
if (universe.IsInitialized)
{
break;
}
}
mainLog.Info("IRSE: Loading Handlers..");
NetworkHandler = new NetworkHandler(ControllerManager);
NetworkHandler.SetupNetworkHandler(server);
PlayerHandler = new PlayerHandler(ControllerManager);
PlayerHandler.SetupPlayerHandler(server);
ChatHandler = new ChatHandler(ControllerManager);
ChatHandler.SetupChatMessageHandler(NetworkHandler);
UniverseHandler = new UniverseHandler(ControllerManager);
UniverseHandler.SetupHandler(server);
mainLog.Info("IRSE: Loaded Universe!");
return(server);
}
catch (ArgumentException ex)
{
mainLog.Error("Failed to get handlers [Argument Exception] \r\n Exception:" + ex.ToString());
return(null);
}
catch (Exception ex)
{
mainLog.Error("Failed to get handlers \r\n Exception: " + ex.ToString());
return(null);
}
}
public WebSocketHandler(WebSocketConnectionManager connectionManager
, ILoggerFactory loggerFactory
, SendFormatFactory sendFormatFactory
, ChatHandler chatHandler)
{
_connectionManager = connectionManager;
_sendFormatFactory = sendFormatFactory;
_chatHandler = chatHandler;
_logger = loggerFactory.CreateLogger <WebSocketHandler>();
}
// Start is called before the first frame update
private void Awake()
{
playerslist = new List <string>();
map = new Dictionary <string, string>();
charTypes = new Queue <string>();
infoObject = GameObject.FindObjectOfType <InfoObject>();
logHandler = GameObject.FindObjectOfType <LogHandler>();
chatHandler = GameObject.FindObjectOfType <ChatHandler>();
chatController = GameObject.FindObjectOfType <ChatController>();
}
private static void SendChatServerMessage(IPacketReceiver client, Character sender, ChatActivableChannelsEnum channel, string message)
{
if (sender.AdminMessagesEnabled)
{
ChatHandler.SendChatAdminServerMessage(client, sender, channel, message);
}
else
{
ChatHandler.SendChatServerMessage(client, sender, channel, message);
}
}
public override void Initialize()
{
ChatHandler.RegisterCommand((Action <string>)LoadExtensionCommand,
"loadextension", "Loads an extension from the disk.");
ChatHandler.RegisterCommand((Action <string, bool>)LoadExtensionsCommand,
"loadextensions", "Loads extensions in a directory from the disk.");
ChatHandler.RegisterCommand((Action <string[]>)LoadExtensionsCommand,
"loadextensions", "Loads an array of extension files.");
ChatHandler.RegisterCommand((Action <string>)LoadExtensionsCommand,
"loadextensions", "Loads extensions in a directory from the disk.");
}
private void Awake()
{
if (PhotonNetwork.IsConnected)
{
mail = GameObject.FindObjectOfType <Email>();
gameData = GameObject.FindObjectOfType <GameData>();
logHandler = GameObject.FindObjectOfType <LogHandler>();
infoObject = GameObject.FindObjectOfType <InfoObject>();
chatHandler = GameObject.FindObjectOfType <ChatHandler>();
timerController = GameObject.FindObjectOfType <TimerController>();
}
}
void Start()
{
pc = player.GetComponent<PlayerControls> ();
l2sc = comicUI.GetComponent<Level2_ShowComic> ();
string endLinesStr = endLines.text;
char[] delimitingChars = {'\n'};
endLinesA = endLinesStr.Split (delimitingChars);
ch = chatHandlerObj.GetComponent<ChatHandler> ();
aus = audioObj.GetComponent<AudioSource> ();
amount = aus.volume / 4;
baseVolume = aus.volume;
}
// Use this for initialization
void Start()
{
once = false;
dc = dcObject.GetComponent<DestroyControls> ();
ca = cameraAniObject.GetComponent<CameraAnimation> ();
ch = chatHandlerObject.GetComponent<ChatHandler> ();
vui = volumeUiObject.GetComponent<VolumeUI> ();
introString = introLinesFile.text;
char[] delimitingChars = {'\n'};
introLines = introString.Split (delimitingChars);
}
public static void DelTele(string[] args)
{
var session = WorldMgr.Session;
var pChar = session.Character;
string location = CommandParser.Read <string>(args, 1);
if (DB.World.Execute("DELETE FROM teleport_locations WHERE location = '{0}'", location))
{
ChatHandler.SendMessageByType(ref session, 0, 0, String.Format("Teleport location '{0}' successfully deleted.", location));
}
}
public void SayAdministrators(WorldClient client, string msg)
{
if (client.UserGroup.Role >= ChatManager.AdministratorChatMinAccess)
{
Singleton <World> .Instance.ForEachCharacter(delegate(Character entry)
{
if (this.CanUseChannel(entry, ChatActivableChannelsEnum.CHANNEL_ADMIN))
{
ChatHandler.SendChatServerMessage(entry.Client, client.Character, ChatActivableChannelsEnum.CHANNEL_ADMIN, msg);
}
});
}
}
public void AddCountToItem(Item item, int count, Item.WINDOW window)
{
for (int i = 0; i < items.Count; i++)
{
if (items[i] == item && items[i].window == window)
{
items[i].count += count;
break;
}
}
ChatHandler.sendLocalChatMessage(owner.client.cid, $"You have received x{count} {item.data.name}");
}
public static void DelTele(string[] args, WorldClass session)
{
var pChar = session.Character;
string location = CommandParser.Read <string>(args, 1);
ChatMessageValues chatMessage = new ChatMessageValues(0, string.Format("Teleport location '{0}' successfully deleted.", location));
if (DB.World.Execute("DELETE FROM teleport_locations WHERE location = ?", location))
{
ChatHandler.SendMessage(ref session, chatMessage);
}
}
public void SayTeam(WorldClient client, string msg)
{
if (!this.CanUseChannel(client.Character, ChatActivableChannelsEnum.CHANNEL_TEAM))
{
ChatHandler.SendChatErrorMessage(client, ChatErrorEnum.CHAT_ERROR_NO_TEAM);
}
else
{
foreach (CharacterFighter current in client.Character.Fighter.Team.GetAllFighters <CharacterFighter>())
{
ChatManager.SendChatServerMessage(current.Character.Client, client.Character, ChatActivableChannelsEnum.CHANNEL_TEAM, msg);
}
}
}
public void SayParty(WorldClient client, string msg)
{
if (!this.CanUseChannel(client.Character, ChatActivableChannelsEnum.CHANNEL_PARTY))
{
ChatHandler.SendChatErrorMessage(client, ChatErrorEnum.CHAT_ERROR_NO_PARTY);
}
else
{
client.Character.Party.ForEach(delegate(Character entry)
{
ChatManager.SendChatServerMessage(entry.Client, client.Character, ChatActivableChannelsEnum.CHANNEL_PARTY, msg);
});
}
}
public void AddItemToInventory(int vnum, int count, Item.WINDOW window)
{
int newPos = getAppropriateWindowPositionForItem(window, vnum);
if (!Config.Items[vnum].stacks && count > 1)
{
count = 1;
}
Item nItem = new Item(owner.data.pid, window, newPos, Config.Items[vnum], -1, count);
items.Add(nItem);
ChatHandler.sendLocalChatMessage(owner.client.cid, $"You have received x{count} {Config.Items[vnum].name}");
}
public void SayGuild(WorldClient client, string msg)
{
if (!this.CanUseChannel(client.Character, ChatActivableChannelsEnum.CHANNEL_GUILD))
{
ChatHandler.SendChatErrorMessage(client, ChatErrorEnum.CHAT_ERROR_NO_GUILD);
}
else
{
client.Character.Guild.Clients.ForEach(delegate(WorldClient entry)
{
ChatManager.SendChatServerMessage(entry, client.Character, ChatActivableChannelsEnum.CHANNEL_GUILD, msg);
});
}
}
public void RemovePlayer(ServerPlayer player, string reason = "")
{
_players.Remove(player);
Game.RemovePlayer(player.Player.Id);
player.Player.OnPropertyChanged -= Player_PropertyChanged;
ChatHandler.SendMessage($"Player {player.Player.Username} left.");
//Try to disconnect them
player?.Connection?.Disconnect(reason);
MessageProcessor.SendMessage(new Common.Actions.ToClient.PlayerLeftAction(player.Player, Game));
}
public static void Handle(UserContext aContext, List <Session> sessions, ConcurrentDictionary <string, Connection> OnlineConnections)
{
var json = aContext.DataFrame.ToString();
logger.Info($"======================================={Environment.NewLine}Received packet: {Environment.NewLine} {json} { Environment.NewLine }=======================================");
dynamic obj = JsonConvert.DeserializeObject(json);
Type type;
MethodInfo metodo;
/*Handlers declaration*/
ChatHandler chatHandler = new ChatHandler();
LoginHandler lh = new LoginHandler();
MessageHandler messageHandler = new MessageHandler();
RegistrationHandler rh = new RegistrationHandler();
switch ((int)obj.Type)
{
case (int)CommandType.Login:
type = lh.GetType();
metodo = type.GetMethod("DoLogin");
metodo.Invoke(lh, new object[] { aContext, sessions, OnlineConnections, obj, json });
break;
case (int)CommandType.Message:
type = messageHandler.GetType();
metodo = type.GetMethod("HandleMessage");
metodo.Invoke(messageHandler, new object[] { aContext, obj, sessions });
break;
case (int)CommandType.ChatsRequest:
type = chatHandler.GetType();
metodo = type.GetMethod("ChatRequestList");
metodo.Invoke(chatHandler, new object[] { sessions, obj });
break;
case (int)CommandType.ChatListRequest:
type = chatHandler.GetType();
metodo = type.GetMethod("ChatRequestList");
metodo.Invoke(chatHandler, new object[] { sessions, obj });
break;
case (int)CommandType.Registration:
type = rh.GetType();
metodo = type.GetMethod("RegisterAccount");
metodo.Invoke(rh, new object[] { obj, aContext });
break;
}
}
public override void OnDestroyEntity(ShEntity entity)
{
base.OnDestroyEntity(entity);
if (entity is ShPlayer victim && bounties.ContainsKey(victim.username))
{
player.svPlayer.Reward(3, 1000);
bounties.Remove(victim.username);
ChatHandler.SendToAll($"{player.username} assassinated {victim.username}");
if (victim == aiTarget)
{
aiTarget = null;
}
}
}
void Start()
{
ch = chatHandlerObj.GetComponent<ChatHandler> ();
linesDictionary = new Dictionary<string, string> ();
char[] firstSplitChars = {'\n'};
char[] secondSplitChars = {':'};
eventLinesString = eventLinesText.text;
string[] lines = eventLinesString.Split (firstSplitChars);
foreach (string s in lines) {
string[] things = s.Split(secondSplitChars);
if (things.Length == 2){
linesDictionary.Add(things[0], things[1]);
}
}
}
void Start()
{
oh = objcHandlerObj.GetComponent<ObjectiveHandler> ();
pv = player.GetComponent<PlayerVolume> ();
sQstring = startQuestText.text;
fQstring = finishQuestText.text;
char[] delimitingChars = {'\n'};
sQLines = sQstring.Split (delimitingChars);
fQLines = fQstring.Split (delimitingChars);
ch = chatHandlerObject.GetComponent<ChatHandler> ();
npcb = this.GetComponent<NPCBehaviour> ();
objectContainer = questObjectContainer.transform;
questStarted = false;
questFinished = false;
r = new Reward (0, levelReward);
q = new Quest (this.gameObject, r, quest_name, quest_description);
}
public virtual void ProcessChat(ChatHandler.MatchContainer match)
{
foreach (Interaction i in InteractionList)
{
foreach (ChatTrigger trig in i.triggerList.GetTriggers(typeof(ChatTrigger)))
{
if (trig.Phrase == match.Command.Phrase && FinalChatCheck(match.Command.Phrase, match.MatchedMessage))
{
OpenChatbagModule.os_log.DebugFormat("[Chatbag]: Interaction {0}.{1} triggered", Name, i.Name);
List<Response> message = i.responses.GetResponse();
foreach( Response r in message ){
switch(r.Volume){
case Response.VolumeType.Global:
ChatHandler.DelayDeliverWorldMessage(Name, r.Channel,
String.Format (r.Text, match.MatchedWording), r.Delay);
break;
case Response.VolumeType.Region:
ChatHandler.DelayDeliverRegionMessage(
match.MatchedMessage.Scene.RegionInfo.RegionID, Name, r.Channel,
String.Format (r.Text, match.MatchedWording), r.Delay);
break;
case Response.VolumeType.Shout:
case Response.VolumeType.Say:
case Response.VolumeType.Whisper:
ChatHandler.DelayDeliverPrimMessage(
tracker.Target, Name, r.Channel, r.Volume,
String.Format (r.Text, match.MatchedWording), r.Delay);
break;
case Response.VolumeType.Private:
ChatHandler.DelayDeliverPrivateMessage(
match.MatchedMessage.SenderUUID, Name,
String.Format (r.Text, match.MatchedWording), r.Delay);
break;
}
}
break;
}
}
}
}
private void Awake()
{
cardClient = GameObject.FindGameObjectWithTag(Tags.Networks).GetComponent<CardClient>();
gameClient = GameClient.Instance;
loginHandler = new LoginHandler();
chatHandler = new ChatHandler();
playerInfoHandler = new PlayerInfoHandler();
cardInfoHandler = new CardInfoHandler();
gameDataHandler = new TCPGameDataHandler();
if (cardClient != null)
{ udpMessageList = cardClient.GetMessageList(); }
else
{ LogsSystem.Instance.Print("UDP数据管理器不存在", LogLevel.ERROR); }
if (gameClient != null)
{ tcpMessageList = gameClient.GetGameDataList(); }
else
{ LogsSystem.Instance.Print("TCP数据管理器不存在", LogLevel.ERROR); }
}
void Start()
{
ch = chatHandlerObj.GetComponent<ChatHandler> ();
entryRectTrans = chatlogEntryPrefab.GetComponent<RectTransform> ();
containerRectTrans = this.GetComponent<RectTransform> ();
}
void Start()
{
startPos = player.transform.position;
ch = chatHandlerObj.GetComponent<ChatHandler> ();
}
void Awake()
{
//Make sure only one ChatHandler object exists
if( m_Instance != null && m_Instance != this )
{
Destroy( gameObject );
return;
}
//The chat client object needs an IChatListener as parameter. The IChatListener interface defines
//several callback methods that the Chat API calls when certain events happened. We made this
//ChatHandler class into an IChatListener so we can pass it as a parameter here
m_ChatClient = new ChatClient( this );
m_Instance = this;
//This GameObject should not be destroyed when a new level is loaded
DontDestroyOnLoad( gameObject );
// this must run in background or it will drop connection if not focused.
Application.runInBackground = true;
}
public override void ProcessChat(ChatHandler.MatchContainer match)
{
if (match.Command.Phrase == "reload_config") ReloadConfig();
base.ProcessChat(match);
}
void Start()
{
if (completeQuestEventObj != null) {
cqe = completeQuestEventObj.GetComponent<CompleteQuestEvent> ();
}
trigger = questTriggerObj.GetComponent<QuestTrigger> ();
sQstring = startQuestText.text;
fAQstring = failedQuestText.text;
fQstring = finishQuestText.text;
char[] delimitingChars = {'\n'};
sQLines = sQstring.Split (delimitingChars);
fQLines = fQstring.Split (delimitingChars);
fAQLines = fAQstring.Split (delimitingChars);
npcb = this.GetComponent<NPCBehaviour> ();
r = new Reward (0, rewardLevels);
q = new Quest (this.gameObject, r, quest_name, quest_description);
ch = chatHandlerObj.GetComponent<ChatHandler> ();
}
private static string USER = "******"; //Something something standard
#endregion Fields
#region Methods
static void Main(string[] args)
{
TcpClient irc;
string inputLine;
StreamWriter writer;
StreamReader reader;
string[] splitInput;
ChatHandler handler = new ChatHandler();
PingSender pingSender;
List<string> response;
try
{
//Connecting to IRC server and channel
irc = new TcpClient(SERVER, PORT);
stream = irc.GetStream();
reader = new StreamReader(stream);
writer = new StreamWriter(stream);
pingSender = new PingSender();
writer.WriteLine("NICK " + NICK);
writer.Flush();
writer.WriteLine(USER);
writer.Flush();
writer.WriteLine("JOIN " + CHANNEL);
writer.Flush();
pingSender.Start();
while(true)
{
while((inputLine = reader.ReadLine()) != null)
{
splitInput = inputLine.Split(new Char[] { ' ' });
if(splitInput[0] != "PONG")
Console.WriteLine(inputLine);
response = handler.Response(inputLine);
if (response != null)
{
if (response[1].Contains("\n"))
{
string[] multiLineResponse = response[1].Split(new Char[] { '\n' });
foreach (string message in multiLineResponse)
{
if (message.Contains("/me"))
{
}
else
{
writer.WriteLine(string.Format("PRIVMSG {0} :{1}", response[0], message));
writer.Flush();
}
}
}
else if(response[1].Contains("/me"))
{
//writer.WriteLine(string.Format("PRIVMSG {0} \x01ACACTION {1}\x01AC"), CHANNEL, response);
//writer.Flush();
}
else
{
writer.WriteLine(string.Format("PRIVMSG {0} :{1}", response[0], response[1]));
writer.Flush();
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Thread.Sleep(15000);
string[] argv = { };
Main(argv);
}
}
void Start()
{
startCheckChat = false;
spawner = spawnerObj.GetComponent<Spawner> ();
oh = objcHandlerObj.GetComponent<ObjectiveHandler> ();
sQstring = startQuestText.text;
fAQstring = failedQuestText.text;
fQstring = finishQuestText.text;
char[] delimitingChars = {'\n'};
sQLines = sQstring.Split (delimitingChars);
fQLines = fQstring.Split (delimitingChars);
fAQLines = fAQstring.Split (delimitingChars);
ch = chatHandlerObj.GetComponent<ChatHandler> ();
npcb = this.GetComponent<NPCBehaviour> ();
rewardHandler = rewardParent.GetComponent<DestructiblesHandler> ();
questStarted = false;
questFinished = false;
r = new Reward (0, rewardLevels);
q = new Quest (this.gameObject, r, quest_name, quest_description);
}
// Use this for initialization
void Start()
{
qm = qmObject.GetComponent<QuestManager> ();
pv = player.GetComponent<PlayerVolume> ();
ch = chatHandlerObj.GetComponent<ChatHandler> ();
if (hasQuest) {
globalQuestID++;
questID = globalQuestID;
addtoGQID ();
questIcon.SetActive (true);
} else {
questIcon.SetActive(false);
}
started = false;
npc_quest_manager = this.GetComponent<NPC_Quest> ();
quest = npc_quest_manager.getQuest ();
}
