// Receive a command from a channel
void OnChannelCommand(ChannelMessageEventArgs channelMessageArgs)
{
if (debugLogChannelMessages) UnityEngine.Debug.Log("IpcIrc:JohnConnor: RECEIVE PUBLIC COMMAND ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
if (debugEchoChannelMessages) IpcIrc.Instance.Message("IpcIrc:JohnConnor: RECEIVE PUBLIC COMMAND ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
string triggerPhrase = "I'm not your ";
if (channelMessageArgs.Message.StartsWith(triggerPhrase)) {
string theCommand = channelMessageArgs.Message.Substring(triggerPhrase.Length);
// react according to the incoming IRC message
switch (theCommand) {
case "guy, friend.":
IpcIrc.Instance.Message(".friend");
break;
case "friend, pal.":
IpcIrc.Instance.Message(".pal");
break;
case "pal, buddy.":
IpcIrc.Instance.Message(".buddy");
break;
case "buddy, guy.":
IpcIrc.Instance.Message(".ping");
break;
default:
IpcIrc.Instance.Message(".pong");
break;
}
}
}
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
switch (channelMessageArgs.Message.ToLower())
{
case "up":
case "down":
case "left":
case "right":
case "start":
case "select":
twitch_output.GetInstance().AddName(channelMessageArgs.From.ToUpper());
twitch_output.GetInstance().AddInput(channelMessageArgs.Message.ToUpper());
GameManager.GetGameManager().current_state.HandleInput(channelMessageArgs.Message.ToLower());
break;
case ":a":
twitch_output.GetInstance().AddName(channelMessageArgs.From.ToUpper());
twitch_output.GetInstance().AddInput("A");
GameManager.GetGameManager().current_state.HandleInput("a");
break;
case ":b":
twitch_output.GetInstance().AddName(channelMessageArgs.From.ToUpper());
twitch_output.GetInstance().AddInput("B");
GameManager.GetGameManager().current_state.HandleInput("b");
break;
}
}
void inDevScan_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder();
if ((e.Message.Command == ChannelCommand.NoteOn) ||
(e.Message.Command == ChannelCommand.NoteOff))
{
/*
* NoteList.Items.Add("nuta");
* if (NoteList.Items.Count >= 20)
* NoteList.Clear();
*/
NoteVal.Text = e.Message.Data1.ToString();
if (e.Message.Command == ChannelCommand.NoteOn)
{
builder.Command = ChannelCommand.NoteOn;
}
if (e.Message.Command == ChannelCommand.NoteOff)
{
builder.Command = ChannelCommand.NoteOff;
}
builder.MidiChannel = e.Message.MidiChannel;
builder.Data1 = e.Message.Data1; // note val
builder.Data2 = e.Message.Data2; // velocity
builder.Build();
outDevice.Send(builder.Result);
}
}
public void OnChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (DeviceID != -1)
{
Device.Send(e.Message);
}
}
public User(ChannelMessageEventArgs msg)
{
_username = msg.From;
_nick = msg.Badge.DisplayName;
_sub = msg.Badge.sub;
_mod = msg.Badge.mod;
}
private void InternalNote(Object o, ChannelMessageEventArgs args)
{
ChannelMessageBuilder builder = new ChannelMessageBuilder(args.Message);
NoteEvent noteEvent = new NoteEvent {
note = builder.Data1,
origNote = builder.Data1,
trackNum = sequencer.GetTrackNum(args.MidiTrack),
track = args.MidiTrack,
};
if (sequencer.GetTrackNum(noteEvent.track) == this.TrackNum)
{
noteEvent.note = NoteHelper.ApplyOctaveShift(noteEvent.note, this.OctaveNum);
ChannelCommand cmd = args.Message.Command;
int vel = builder.Data2;
if ((cmd == ChannelCommand.NoteOff) || (cmd == ChannelCommand.NoteOn && vel == 0))
{
this.ProcessOffNote(noteEvent);
}
if ((cmd == ChannelCommand.NoteOn) && vel > 0)
{
this.ProcessOnNote(noteEvent);
}
}
}
protected void RaiseMessageReceivedEvent(object sender, ChannelMessageEventArgs e)
{
if (MessageReceived != null)
{
MessageReceived(sender, e);
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e) // Event Handler for MIDI messages
{
// context.Post(delegate(object dummy)
// {
/* System.Diagnostics.Debug.WriteLine(
* e.Message.Command.ToString() + '\t' + '\t' +
* e.Message.MidiChannel.ToString() + '\t' +
* e.Message.Data1.ToString() + '\t' +
* e.Message.Data2.ToString());*/
// }, null); // Writes all channel messages to output console
outmess.Note = e.Message.Data1; // Insert channel messages to variable struct: Note
outmess.Mess = e.Message.Data2; // Velocity
if (e.Message.Command.Equals(n))
{
outmess.isCC = false; // set false if the output message is a NoteOn message
}
else
{
outmess.isCC = true; // True if output message is a Control Change (only two types of message possible)
}
ControlSender = true;
sortOutmess(outmess); // use messages to change parameters
ControlSender = false;
if (inForm != null)
{
inForm.ChangeStatusText();
}
}
private static void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
System.Diagnostics.Debug.WriteLine(string.Format("{0}, {1}, {2}, {3}, {4}, {5}", e.Message.Command.ToString(),
e.Message.Data1, e.Message.Data2, e.Message.MessageType.ToString(), e.Message.MidiChannel, e.Message.Status));
switch (e.Message.Command)
{
case ChannelCommand.NoteOn:
foreach (VirtualPiano inst in _pianoInstances)
{
inst.handlePianoDown(e.Message.Data1);
}
break;
case ChannelCommand.NoteOff:
foreach (VirtualPiano inst in _pianoInstances)
{
inst.handlePianoUp(e.Message.Data1);
}
break;
default:
break;
}
}
private void Indev_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (isMapping)
{
((MixerInput)mappingList.SelectedValue).mapping = new MixerInput.MidiMapping(e.Message.Command, e.Message.Data1);
stopMapping();
}
else
{
foreach (MixerInput inpt in inputList)
{
if (inpt.mapping != null && inpt.mapping.Command == e.Message.Command && inpt.mapping.Data1 == e.Message.Data1)
{
long id;
inpt.input.GetInputId(out id);
mixEffectBlock1.SetInt(_BMDSwitcherMixEffectBlockPropertyId.bmdSwitcherMixEffectBlockPropertyIdPreviewInput, id);
}
}
}
if (e.Message.Command == ChannelCommand.Controller && e.Message.Data1 == 0)
{
float val = ((float)e.Message.Data2) / 127f;
if (invertSlider)
{
val = 1.0f - val;
}
if (val == 1.0f)
{
invertSlider = !invertSlider;
}
mixEffectBlock1.SetFloat(_BMDSwitcherMixEffectBlockPropertyId.bmdSwitcherMixEffectBlockPropertyIdTransitionPosition, val);
}
}
private void OnChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
string logMessage = null;
Note n = (Note)(e.Message.Data1 % 12);
int octave = e.Message.Data1 / 12;
switch (e.Message.Command)
{
case ChannelCommand.NoteOn:
MidiState.Current.SetValue(e.Message.MidiChannel, n, octave, e.Message.Data2);
NoteChanged?.Invoke(e.Message.MidiChannel, n, octave, e.Message.Data2);
break;
case ChannelCommand.NoteOff:
MidiState.Current.SetValue(e.Message.MidiChannel, n, octave, 0);
NoteChanged?.Invoke(e.Message.MidiChannel, n, octave, e.Message.Data2);
break;
case ChannelCommand.ChannelPressure:
Console.ForegroundColor = ConsoleColor.DarkBlue;
logMessage = $"Aftertouch> {e.Message.Data1}, CH#{e.Message.MidiChannel}).";
ChannelPressureChanged?.Invoke(e.Message.MidiChannel, e.Message.Data1);
break;
default:
Console.ForegroundColor = ConsoleColor.DarkGray;
logMessage = $"CH#{e.Message.MidiChannel} Command: {e.Message.Command}, Data1: {e.Message.Data1}, Data2: {e.Message.Data2}).";
break;
}
if (logMessage != null)
{
Console.WriteLine(logMessage);
}
}
public static void HandleEmoji(ChannelMessageEventArgs msg)
{
if (!VoteCommands.started)
{
return;
//ReplyAsync($"@{Context.User.Nick} голосование не начато!");
}
if (!VoteCommands.EmodjiVote)
{
return;
//ReplyAsync($"@{Context.User.Nick} Во время голосования смайлами это недоступно");
}
if (SubOnly)
{
if (!msg.Badge.sub)
{
return;
}
}
var arr = msg.Message.Split(' ');
if (VoteCommands.EmojiVariants.ContainsKey(arr[0]))
{
if (VoteCommands.EmojiVotes.ContainsKey(msg.From))
{
VoteCommands.EmojiVotes[msg.From] = arr[0];
}
else
{
VoteCommands.EmojiVotes.Add(msg.From, arr[0]);
}
}
}
private void inputDevice_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
this.log.Verbose("Recv {4} cmd {0}, chn: {1} data1: {2} data2: {3}",
e.Message.Command,
e.Message.MidiChannel,
e.Message.Data1,
e.Message.Data2,
Name);
this.midiMessages.OnNext(e.Message);
try
{
var key = Tuple.Create(e.Message.MidiChannel, e.Message.Command, e.Message.Data1);
Action <ChannelMessage> action;
if (this.messageMapper.TryGetValue(key, out action))
{
action.Invoke(e.Message);
}
}
catch (Exception ex)
{
log.Error(ex, "Failed to invoke action");
}
}
void _chat_ChannelMessageEvent(Vha.Net.Chat chat, ChannelMessageEventArgs e)
{
Channel channel = this.GetChannel(e.Channel);
// Check if channel is muted
if (channel != null && (channel.Flags & ChannelFlags.Muted) != 0)
{
return;
}
// Check for ignores
if (this.Ignores.Contains(e.Character))
{
return;
}
// Descramble
string message = e.Message;
if (e.Message.StartsWith("~"))
{
MDB.Message parsedMessage = null;
try { parsedMessage = MDB.Parser.Decode(e.Message); }
catch (Exception) { } // Errors are fine here, if it's not a valid message, we'll display the original
if (parsedMessage != null && !string.IsNullOrEmpty(parsedMessage.Value))
{
message = parsedMessage.Value;
}
}
// Dispatch message
MessageSource source = new MessageSource(MessageType.Channel, e.Channel, e.Character, e.Character == this.Character);
this.Write(source, this.GetChannelClass(e.Channel), message);
}
private void storeMidiEvent(object sender, ChannelMessageEventArgs e)
{
if (seq.IsGamedStarted())
{
midiEvents.Add(new MidiEventStorage(e, Time.time - seq.GetStartTime()));
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (OnMidiValueChanged != null)
{
OnMidiValueChanged(mName, e.Message.Command.ToString(), e.Message.MidiChannel, e.Message.Data1, e.Message.Data2);
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
int resultLow = 0;
int resultMidle = 0;
int resultHigh = 0;
int bitMaskLowestByte = 0x0000FF;
int bitMaskMidleByte = 0x00FF00;
int bitMaskHighByte = 0xFF0000;
resultLow = e.Message.Message & bitMaskLowestByte;
resultMidle = (e.Message.Message & bitMaskMidleByte) >> 8;
resultHigh = (e.Message.Message & bitMaskHighByte) >> 16;
//Console.WriteLine(resultLow.ToString("X") + " " + resultMidle.ToString("X") + " " + resultHigh.ToString("X"));
switch (resultMidle)
{
case 0x00:
masterVolumeSlider.Value = prozentConversion(resultHigh, 0x7F);
break;
case 0x44:
break;
default:
break;
}
}
private void MidiIn_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (e.Message.MidiChannel == MidiChannel)
{
if (e.Message.MessageType == MessageType.Channel && e.Message.Command == ChannelCommand.NoteOn)
{
lock (MidiIn)
{
if (NoteReceiver == null)
{
NoteReceiver = new NoteTimecodeReceiver();
}
NoteReceiver.AddNote(e.Message.Data1);
if (NoteReceiver.StartBeatNumber != null && !TabitCurrentlyPlaying)
{
TimecodeTransmissionStarted(this, new TransmissionStartedEventArgs(NoteReceiver.StartBeatNumber.Value));
TabitCurrentlyPlaying = true;
Timer.Start();
}
}
}
}
}
} // Subscribe
// Receive a message from a channel and dispatch it
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
if (channelMessageArgs.Message.StartsWith(triggerPhrase))
{
OnChannelEvent(channelMessageArgs);
}
}
/// <summary>
/// Channel messages (notes)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (closing)
{
return;
}
/*
* context.Post(delegate (object dummy)
* {
*
* // Display notes
* channelListBox.Items.Add(
* e.Message.Command.ToString() + '\t' + '\t' +
* e.Message.MidiChannel.ToString() + '\t' +
* e.Message.Data1.ToString() + '\t' +
* e.Message.Data2.ToString()
* );
*
* channelListBox.SelectedIndex = channelListBox.Items.Count - 1;
*
* outDevice.Send(e.Message);
*
* }, null);
*/
outDevice.Send(e.Message);
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
//context.Post(delegate(object dummy)
//{
textBox1.Text += "message = " + e.Message.Command + "; ID" + e.Message.Data1 + "\r\n";
int PanelID = e.Message.Data1;
for (int x = 0; x < 4; x++)
{
for (int y = 0; y < 4; y++)
{
if (Convert.ToInt32(panele[x, y].Tag) == PanelID)
{
//if (e.Message.Command == ChannelCommand.NoteOn)
// ZapalPanel(panele[x, y], Color.Orange);
//else
// ZapalPanel(panele[x, y], Color.Black);
if (e.Message.Command == ChannelCommand.NoteOff)
{
panel13_MouseClick(panele[x, y], null);
}
}
}
}
//}, null);
//SprawdzDroge_Click(null, null);
}
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (closing)
{
return;
}
outDevice.Send(e.Message);
}
private void HandleChannelMessage(object sender, ChannelMessageEventArgs e)
{
var channel = 1;//e.Message.MidiChannel;
var cc = e.Message.Data1;
var value = e.Message.Data2;
MessageReadyEvent?.Invoke(channel, cc, value);
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
_context.Post(delegate
{
channelListBox.Items.Add(
e.Message.Command.ToString() + '\t' + '\t' +
e.Message.MidiChannel + '\t' +
e.Message.Data1 + '\t' +
e.Message.Data2);
channelListBox.TopIndex = channelListBox.Items.Count - 1;
// first keyboard key (lower C)
if (e.Message.Data1 == 48 && e.Message.Command == ChannelCommand.NoteOn)
{
ReloadMapping();
return;
}
// just testing
if (e.Message.Command == ChannelCommand.PitchWheel)
{
Console.WriteLine($"SpeedRatio: {e.Message.Data2} {e.Message.Data1}");
return;
}
// first dial on set of 8 dials on top right of AKAI MPL mini
if (e.Message.Data1 == 1)
{
_volume = e.Message.Data2 / 127.0f;
_mediaPlayer.Volume = _volume;
return;
}
if (e.Message.Data1 == 2)
{
_volume = e.Message.Data2 / 127.0f;
_mediaPlayer.Pause();
_mediaPlayer.SpeedRatio = e.Message.Data2 / 127.0f;
_mediaPlayer.Play();
return;
}
if (e.Message.Command != ChannelCommand.NoteOff)
{
return;
}
if (_sounds.TryGetValue(e.Message.Data1.ToString(), out var soundFile))
{
var docs = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var effects = Path.Combine(docs, "SoundBoard");
var sfx = Path.Combine(effects, soundFile);
Play(sfx);
}
channelListBox.SelectedIndex = channelListBox.Items.Count - 1;
}, null);
public CommandContext(ChannelMessageEventArgs msg)
{
Channel = new Channel()
{
ChannelID = msg.Channel
};
User = new User(msg);
Message = msg.Message;
}
public override bool OnChannelMessage(object sender, ChannelMessageEventArgs e)
{
if (((IrcClient)sender).Address.EndsWith(".DCC") || (sender == this.ArenaConnection && ((IrcClient)sender).CaseMappingComparer.Equals(e.Channel.Name, this.ArenaChannel) &&
((IrcClient)sender).CaseMappingComparer.Equals(e.Sender.Nickname, this.ArenaNickname)))
{
this.RunArenaRegex((IrcClient)sender, e.Channel, e.Sender, e.Message);
}
return(base.OnChannelMessage(sender, e));
}
private void SequenceChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
// TODO: improve this
// this stops both on AND off messages, so if channel is toggled mid-play, notes can hang
if (_channels[e.Message.MidiChannel])
{
_outDevice.Send(e.Message);
}
}
void m_Sequencer_ChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
/*if (closing)
* {
* return;
* }*/
m_OutputDevice.Send(e.Message);
}
private void OffPlayerMidiNote(Object o, ChannelMessageEventArgs e)
{
OffMidiNote?.Invoke(o, new NoteEvent {
track = e.MidiTrack,
trackNum = GetTrackLutNum(e.MidiTrack),
note = ApplyOctaveShift(e.Message.Data1),
origNote = e.Message.Data1,
});
}
public void ExecuteAction(ChannelMessageEventArgs e)
{
int pitch = e.Message.Data1;
if (ActionMappings.ContainsKey(pitch))
{
ActionMappings[pitch](e);
}
}
public override bool OnChannelNotice(object sender, ChannelMessageEventArgs e)
{
if (!IsActiveChannel(e.Channel))
{
return(false);
}
this.SendCheck(string.Format("\u000315[\u000F{0}\u000315/\u000F{1}\u000315] {2}{3}\u00038:\u000F {4}", e.Channel, (sender as IrcClient).NetworkName, Colours.NicknameColour(e.Sender.Nickname), e.Sender.Nickname, e.Message), (IrcClient)sender, e.Channel);
return(base.OnChannelNotice(sender, e));
}
// Receive an event from a channel and dispatch it
void OnChannelEvent(ChannelMessageEventArgs channelMessageArgs)
{
string theEvent = channelMessageArgs.Message.Substring(triggerPhrase.Length + 1);
// The +1 consumes the implicit space after the trigger phrase!
foreach (var item in myEventList) {
if (theEvent.StartsWith(item.startsWith)) {
item.triggerEvent.Invoke();
}
}
}
public static void CreateNewUser(string username, ChannelMessageEventArgs command)
{
PokemonTrainer pt = new PokemonTrainer();
pt.trainerLevel = 1;
pt.wins = 0;
pt.losses = 0;
pt.pokemon = new List<Pokemon>();
PokemonMaster.Instance.trainerList.Add(username, pt);
SaveTrainerList();
PokemonMaster.Instance.CheckForCommands(command);
}
public void CheckForCommands(ChannelMessageEventArgs command)
{
if (enabled == false)
return;
if (awaitingRelease && currentOperator != command.From)
return;
if (awaitingChallenger && currentOperator == command.From && !command.Message.Contains("!battle"))
return;
if (!busy || awaitingRelease || awaitingChallenger)
if (command.Message.StartsWith("!"))
if (CheckForUser(command.From, command)) {
currentOperator = command.From;
if (command.Message.Contains("!pokemon")) {
ParsePokemon(command);
}
if (command.Message.Contains("!pokeball")) {
StartCoroutine(Pokeball(command, useMasterball));
}
if (command.Message.Contains("!trainer")) {
TwitchIrc.Instance.Message("Feature under construction. Please check back later to learn more about yourself!");
}
if (command.Message.Contains("!battle")) {
if (!awaitingChallenger) {
if (trainerList[command.From].pokemon.Count >= 1) {
combatantOne = command.From;
string[] s = command.Message.Split(' ');
if (s.Length == 2)
if (trainerList[command.From].pokemon[Convert.ToInt16(s[1])].name != null)
combatantOnePokemon = trainerList[command.From].pokemon[Convert.ToInt16(s[1])];
else
combatantOnePokemon = trainerList[command.From].pokemon[UnityEngine.Random.Range(0, trainerList[command.From].pokemon.Count - 1)];
awaitingChallenger = true;
TwitchIrc.Instance.Message(command.From + " has issued a challenge to all Trainers. Who will accept? (use !battle # to accept)");
}
}
else {
if (trainerList[command.From].pokemon.Count >= 1) {
combatantTwo = command.From;
string[] s = command.Message.Split(' ');
if (s.Length == 2)
combatantTwoPokemon = trainerList[command.From].pokemon[Convert.ToInt16(s[1])];
else
combatantTwoPokemon = trainerList[command.From].pokemon[UnityEngine.Random.Range(0, trainerList[command.From].pokemon.Count - 1)];
awaitingChallenger = false;
//StartCoroutine(Battle());
}
}
}
if (command.Message.Contains("!help")) {
TwitchIrc.Instance.Message("Commands available to play Pokemon are: !pokemon, !pokeball, !battle, and !trainer.");
}
}
}
//Receive username that has been left from channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
Debug.Log("MESSAGE: " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
var existingWatcher = _watchers.FirstOrDefault(w => w.Name == channelMessageArgs.From);
if (existingWatcher == null)
{
Watcher anyFreeWatcher = _watchers.FirstOrDefault(w => String.IsNullOrEmpty(w.Name));
if (anyFreeWatcher != null)
{
existingWatcher = anyFreeWatcher;
existingWatcher.Name = channelMessageArgs.From;
}
}
if (existingWatcher != null)
{
existingWatcher.Shout(channelMessageArgs.Message);
}
}
public void CheckForCommands(ChannelMessageEventArgs channelMessageArgs)
{
if (enabled == false)
return;
if (!busy) {
if (channelMessageArgs.Message.StartsWith("!")) {
if (channelMessageArgs.Message.Contains("!shipcreate")) {
CreateNewPlayer(channelMessageArgs.From);
return;
}
if (channelMessageArgs.Message.Contains("!shiptrade")) {
if (CheckForPlayer(channelMessageArgs.From))
TradeMission(channelMessageArgs.From);
return;
}
if (channelMessageArgs.Message.Contains("!shipbattle")) {
if (CheckForPlayer(channelMessageArgs.From))
BattleMission(channelMessageArgs.From);
return;
}
if (channelMessageArgs.Message.Contains("!shippirate")) {
TwitchIrc.Instance.Message("This feature currently under construction. Check back soon!");
return;
}
if (channelMessageArgs.Message.Contains("!shipupgrade")) {
if (CheckForPlayer(channelMessageArgs.From))
ParseUpgradeCommand(channelMessageArgs.From, channelMessageArgs.Message);
return;
}
if (channelMessageArgs.Message.Contains("!shiphelp")) {
if (CheckForPlayer(channelMessageArgs.From))
TwitchIrc.Instance.Message("Seven Seas' commands are: !shipcreate, !shipinfo, !shiptrade, !shipbattle, !shippirate, !shipupgrade [guns, hull, sails, crew]");
return;
}
if (channelMessageArgs.Message.Contains("!shipinfo")) {
if (CheckForPlayer(channelMessageArgs.From))
ShipInfo(channelMessageArgs.From);
return;
}
}
}
}
// Receive a message from a channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
if (debugLogChannelMessages) UnityEngine.Debug.Log("IpcIrc:JohnConnor: RECEIVE PUBLIC MESSAGE ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
if (debugEchoChannelMessages) IpcIrc.Instance.Message("IpcIrc:JohnConnor: RECEIVE PUBLIC MESSAGE ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
if (channelMessageArgs.Message.StartsWith("I'm not your ")) {
OnChannelCommand(channelMessageArgs);
}
}
private bool CheckForUser(string username, ChannelMessageEventArgs command)
{
if (trainerList.ContainsKey(username)) {
Debug.Log(username + " found.");
return true;
}
else {
Debug.LogError("No key found for this user. Creating one.");
PokemonUtils.CreateNewUser(username, command);
return false;
}
}
private void ParsePokemon(ChannelMessageEventArgs command)
{
if (command.Message.Length == 8) {
TwitchIrc.Instance.Message(PokemonUtils.GetUserPokemon(command.From));
}
else if (command.Message.Length == 10) {
string[] commandArray = command.Message.Split(' ');
TwitchIrc.Instance.Message(PokemonUtils.FormatPokemonInfo(trainerList[command.From].pokemon[Convert.ToInt16(commandArray[1]) - 1]));
}
else {
string[] commandArray = command.Message.Split(' ');
if (commandArray.Length >= 3 && awaitingRelease) {
if (commandArray[1] == "release" || commandArray[1] == "Release") {
int index = Convert.ToInt16(commandArray[2]);
if (index == 0) {
awaitingRelease = false;
return;
}
SwapPokemon(command.From, recentlyCaught, index);
busy = false;
awaitingRelease = false;
}
}
}
}
// Receive a message from a channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
AppendAndScroll("<b>" + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ":</b> " + channelMessageArgs.Message);
}
//Receive username that has been left from channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
Debug.Log("MESSAGE: " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
ChatText.text += "<b>" + channelMessageArgs.From + ":</b> " + channelMessageArgs.Message + "\n";
if ((StarGameTimer > Time.time) || (EndGameTimer < Time.time))
{
// game isn't running.
return;
}
bool left = findPlayerGroup(channelMessageArgs.From);
Debug.Log("'" + channelMessageArgs.Message + "'");
char c = channelMessageArgs.Message[0];
if (c == ':')
c = channelMessageArgs.Message[1];
if (left) {
LogLeftText.text += "<color=blue>" + channelMessageArgs.From + ":" + c
+"</color>\n";
}
else {
LogRightText.text += "<color=red>" + channelMessageArgs.From + ":" + c
+ "</color>\n";
}
int hamletScore = 1;
string[] words = channelMessageArgs.Message.Split(' ');
MakeParticleText(left ? leftImage : rightImage, words[0]);
if (hamlet.IsHamlet(words[0]))
{
MakeParticleHamlet(left ? leftImage : rightImage);
hamletScore = 10;
}
/*
string upperC = c.ToString().ToUpper();
if (upperC != "R" && upperC != "P" && upperC !="S") {
}*/
switch (c)
{
case 'r':
case 'R':
if (left)
{
leftRock+= hamletScore;
MakeParticle(leftImage, LeftRockSprite);
}
else
{
rightRock+= hamletScore;
MakeParticle(rightImage, RightRockSprite);
}
break;
case 'p':
case 'P':
if (left)
{
leftPaper+= hamletScore;
MakeParticle(leftImage, LeftPaperSprite);
}
else
{
rightPaper+= hamletScore;
MakeParticle(rightImage, RightPaperSprite);
}
break;
case 's':
case 'S':
if (left)
{
leftScissors+= hamletScore;
MakeParticle(leftImage, LeftScissorsSprite);
}
else
{
rightScissors+= hamletScore;
MakeParticle(rightImage, RightScissorsSprite);
}
break;
default:
break;
}
rightRockText.text = rightRock.ToString();
rightScissorsText.text = rightScissors.ToString();
rightPaperText.text = rightPaper.ToString();
leftRockText.text = leftRock.ToString();
leftScissorsText.text = leftScissors.ToString();
leftPaperText.text = leftPaper.ToString();
Debug.Log(c + " " + leftRock + "," + leftPaper + "," + leftScissors + " " + rightRock + "," + rightPaper + "," + rightScissors);
}
//Receive username that has been left from channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
ChatText.text += "<b>" + channelMessageArgs.From + ":</b> " + channelMessageArgs.Message + "\n";
Debug.Log("MESSAGE: " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
twitchPlayerManager.chatReceived(channelMessageArgs.From, channelMessageArgs.Message);
}
private void PrintChat(ChannelMessageEventArgs message)
{
if (chatBox.text.Length >= 5000) {
if (message.Message.Length <= chatBox.text.Length)
chatBox.text = chatBox.text.Remove(0, message.Message.Length);
else
chatBox.text = chatBox.text.Remove(0, 30);
}
if (alternateTextColor) {
chatBox.text += "<color=#00ffffff><b><size=16>" + message.From + ":</size></b></color> " + message.Message + "\n";
alternateTextColor = false;
}
else {
chatBox.text += "<color=#ff9900ff><b><size=16>" + message.From + ":</size></b></color> " + message.Message + "\n";
alternateTextColor = true;
}
}
// Receive a message from a channel and dispatch it
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
if (channelMessageArgs.Message.StartsWith(triggerPhrase)) {
OnChannelEvent(channelMessageArgs);
}
}
// Receive a message from a channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
if (debugLogChannelMessages) UnityEngine.Debug.Log("IpcIrcDebug: MESSAGE ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
if (debugEchoChannelMessages) IpcIrc.Instance.Message("IpcIrcDebug: MESSAGE ON " + channelMessageArgs.Channel + ": " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
}
private IEnumerator Pokeball(ChannelMessageEventArgs command, bool masterball)
{
busy = true;
Pokemon p = GeneratePokemon();
int trainerBonus = Mathf.FloorToInt(trainerList[command.From].trainerLevel / 2);
TwitchIrc.Instance.Message(command.From + " throws a Pokeball at a " + p.name + ". They have a " + (int)((p.catchRate / 255f) * 100) + "% chance of catching it without a battle!");
int random = UnityEngine.Random.Range(0, 255) + trainerBonus;
if (masterball) random = 0;
yield return new WaitForSeconds(5f);
TwitchIrc.Instance.Message("The pokeball glows and shakes.");
yield return new WaitForSeconds(5f);
if (random <= p.catchRate) {
recentlyCaught = p;
if (trainerList[command.From].pokemon.Count >= 6) {
//Too many pokemon, must release one to keep this new one.
TwitchIrc.Instance.Message("You have too many pokemon currently. Please use !pokemon release # to replace it with this new " + p.name + " or !pokemon release 0 to release " + p.name + ". You have 30 seconds.");
float timer = 30f;
awaitingRelease = true;
while (timer > 0f && awaitingRelease == true) {
timer -= Time.deltaTime;
Debug.Log((int)timer);
yield return null;
}
TwitchIrc.Instance.Message("You've released the " + recentlyCaught.name + ".");
recentlyCaught = new Pokemon();
}
else {
TwitchIrc.Instance.Message(command.From + " caught a " + p.name + "!");
trainerList[command.From].pokemon.Add(p);
PokemonUtils.SaveTrainerList();
busy = false;
}
}
//TODO Look into using the battle system to resolve this more fairly than just a random number generating the "damage" the pokemon took in battle
else if ((p.hitpoints * 255 * 4) / ((UnityEngine.Random.Range(0, p.hitpoints) + 20) * 12) >= UnityEngine.Random.Range(0, 255)) {
recentlyCaught = p;
if (trainerList[command.From].pokemon.Count >= 6) {
//Too many pokemon, must release one to keep this new one.
TwitchIrc.Instance.Message("You have too many pokemon currently. Please use !pokemon release # to replace it with this new " + p.name + " or !pokemon release 0 to release " + p.name + ". You have 30 seconds.");
awaitingRelease = true;
}
else {
TwitchIrc.Instance.Message(command.From + " caught a " + p.name + "!");
trainerList[command.From].pokemon.Add(p);
PokemonUtils.SaveTrainerList();
busy = false;
}
}
else {
TwitchIrc.Instance.Message("The " + p.name + " has escaped. Better luck next time.");
busy = false;
}
}
private void OnChannelMessage(ChannelMessageEventArgs channelMessageEventArgs)
{
// Announce
if (MessageReceived != null)
{
MessageReceived(channelMessageEventArgs.From, channelMessageEventArgs.Message);
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
int data1 = e.Message.Data1;
int data2 = e.Message.Data2;
//Debug.Log(data1.ToString() + ", " + data2.ToString());
if (data1 == 1) //... obsluga pokretla do nabijania combosow
{
if (up)
{
if (data2 > 90)
{
up = false;
GameManager.Instance.IncreaseCombo();
}
}
else if (!up)
{
if (data2 < 30)
{
up = true;
GameManager.Instance.IncreaseCombo();
}
}
}
else //... obsluga klawiszy odpowiedzialnych za sterowanie maszynami
{
if (data1 == 60 && key01pressed == false)
{
key01pressed = true;
GameManager.Instance.AddPressedKey(data1);
}
else if (data1 == 60 && key01pressed == true)
{
key01pressed = false;
}
if (data1 == 62 && key02pressed == false)
{
key02pressed = true;
GameManager.Instance.AddPressedKey(data1);
}
else if (data1 == 62 && key02pressed == true)
{
key02pressed = false;
}
if (data1 == 64 && key03pressed == false)
{
key03pressed = true;
GameManager.Instance.AddPressedKey(data1);
}
else if (data1 == 64 && key03pressed == true)
{
key03pressed = false;
}
if (data1 == 65 && key04pressed == false)
{
key04pressed = true;
GameManager.Instance.AddPressedKey(data1);
}
else if (data1 == 65 && key04pressed == true)
{
key04pressed = false;
}
if (data1 == 67 && key05pressed == false)
{
key05pressed = true;
GameManager.Instance.AddPressedKey(data1);
}
else if (data1 == 67 && key05pressed == true)
{
key05pressed = false;
}
}
}
//Receive username that has been left from channel
void OnChannelMessage(ChannelMessageEventArgs channelMessageArgs)
{
ChatText.text += "<b>" + channelMessageArgs.From + ":</b> " + channelMessageArgs.Message + "\n";
Debug.Log("MESSAGE: " + channelMessageArgs.From + ": " + channelMessageArgs.Message);
}
