app/TwitchBot/TwitchChatBot.php

   1 <?php
   2
   3 namespace App\TwitchBot;
   4
   5 use App\Models\Channel;
   6 use App\Models\ChatBotLog;
   7 use App\Models\ChatLib;
   8 use App\Models\ChatLog;
   9 use Illuminate\Support\Arr;
  10 use Illuminate\Support\Str;
  11
  12 class TwitchChatBot extends TwitchBot {
  13
  14         public function __construct() {
  15                 parent::__construct('horstiebot');
  16                 $this->updateChannels();
  17                 $this->startTimer();
  18                 $this->listenCommands();
  19                 $this->chatlib = new ChatLib();
  20                 $this->chatlib->loadFrom('de');
  21         }
  22
  23         public function joinChannels() {
  24                 $this->getLogger()->info('joining channels');
  25                 $names = [];
  26                 foreach ($this->channels as $channel) {
  27                         $names[] = $channel->twitch_chat;
  28                 }
  29                 $chunks = array_chunk($names, 10);
  30                 foreach ($chunks as $chunk) {
  31                         $this->sendIRCMessage(IRCMessage::join($chunk));
  32                 }
  33         }
  34
  35         public function logMessage(IRCMessage $msg) {
  36                 $channel = $this->getMessageChannel($msg);
  37                 if ($channel && !$channel->join) {
  38                         $msg->log();
  39                 }
  40         }
  41
  42         public function handlePrivMsg(IRCMessage $msg) {
  43                 if ($msg->nick == 'horstiebot') return;
  44                 $channel = $this->getMessageChannel($msg);
  45                 if (!$channel) return;
  46                 $this->tagChannelRead($channel, $msg);
  47         }
  48
  49         public function handleWhisper(IRCMessage $msg) {
  50                 $text = $this->chatlib->generate($msg->getText());
  51                 $this->sendWhisper($msg->tags['user-id'], $text);
  52         }
  53
  54         public function getChatlibDatabase(Channel $channel) {
  55                 return $this->chatlib;
  56         }
  57
  58
  59         private function startTimer() {
  60                 $this->getLoop()->addPeriodicTimer(1, function () {
  61                         if (!$this->isReady()) return;
  62                         foreach ($this->channels as $channel) {
  63                                 $this->decideSend($channel);
  64                         }
  65                 });
  66                 $this->getLoop()->addPeriodicTimer(60, function () {
  67                         $this->updateChannels();
  68                 });
  69         }
  70
  71         private function updateChannels() {
  72                 $this->channels = Channel::where('twitch_chat', '!=', '')->where('chat', '=', true)->get();
  73         }
  74
  75         private function decideSend(Channel $channel) {
  76                 $notes = $this->getNotes($channel);
  77                 if ($notes['read_since_last_write'] < $notes['wait_msgs']) {
  78                         return;
  79                 }
  80                 if (time() - $notes['last_write'] < $notes['wait_time']) {
  81                         return;
  82                 }
  83                 if ($notes['read_since_last_write'] == $notes['wait_msgs'] && time() - $notes['last_read'] < 3) {
  84                         // don't immediately respond if we crossed the msg threshold last
  85                         return;
  86                 }
  87                 $text = $this->contextualMsg($channel);
  88                 if (!$text && $this->shouldAdlib($channel)) {
  89                         $this->performAdlib($channel);
  90                         return;
  91                 }
  92                 if (!$text) $text = $this->randomChat($channel);
  93                 if (!$text) return;
  94                 $actual_text = is_object($text) ? $text->text_content : $text;
  95                 $this->tagChannelWrite($channel);
  96                 $this->sendIRCMessage(IRCMessage::privmsg($channel->twitch_chat, $actual_text));
  97                 $log = new ChatBotLog();
  98                 $log->channel()->associate($channel);
  99                 if (is_object($text)) {
 100                         $log->origin()->associate($text);
 101                         $log->category = $text->classification;
 102                 } else {
 103                         $log->category = $this->getLastSpecialSent($channel);
 104                 }
 105                 $log->text = $actual_text;
 106                 $log->save();
 107         }
 108
 109         private function getNotes(Channel $channel) {
 110                 if (!isset($this->notes[$channel->id])) {
 111                         $this->notes[$channel->id] = [
 112                                 'last_read' => 0,
 113                                 'last_special' => [],
 114                                 'last_write' => time(),
 115                                 'latest_msgs' => [],
 116                                 'queued_special' => false,
 117                                 'read_since_last_write' => 0,
 118                                 'wait_msgs' => $this->randomWaitMsgs($channel),
 119                                 'wait_time' => $this->randomWaitTime($channel),
 120                         ];
 121                 }
 122                 return $this->notes[$channel->id];
 123         }
 124
 125         private function getNote(Channel $channel, $name, $default = null) {
 126                 $notes = $this->getNotes($channel);
 127                 if (array_key_exists($name, $notes)) {
 128                         return $notes[$name];
 129                 }
 130                 return $default;
 131         }
 132
 133         private function setNote(Channel $channel, $name, $value) {
 134                 $this->getNotes($channel);
 135                 $this->notes[$channel->id][$name] = $value;
 136         }
 137
 138         private function collectClassifications(Channel $channel) {
 139                 $classifications = [];
 140                 $notes = $this->getNotes($channel);
 141                 foreach ($notes['latest_msgs'] as $msg) {
 142                         $classification = $msg->classify();
 143                         if ($classification == 'unclassified') continue;
 144                         if (isset($classifications[$classification])) {
 145                                 ++$classifications[$classification];
 146                         } else {
 147                                 $classifications[$classification] = 1;
 148                         }
 149                 }
 150                 arsort($classifications);
 151                 return $classifications;
 152         }
 153
 154         private function contextualMsg(Channel $channel) {
 155                 if ($this->hasQueuedSpecial($channel)) {
 156                         $classification = $this->getQueuedSpecial($channel);
 157                         if (is_string($classification)) {
 158                                 $this->tagChannelSpecialSent($channel, $classification);
 159                         }
 160                         $this->clearQueuedSpecial($channel);
 161                         return $this->getRandomOfClass($channel, $classification);
 162                 }
 163                 $latest_msg = $this->getLatestMessage($channel);
 164                 if ($latest_msg->classify() == 'question') {
 165                         $response = $latest_msg->getResponseCategory();
 166                         return $this->getRandomOfClass($channel, $response);
 167                 }
 168                 $last = $this->getLastSpecialSent($channel);
 169                 $classifications = $this->collectClassifications($channel);
 170                 $count_quotas = [
 171                         'gg' => 2,
 172                         'gl' => 2,
 173                         'hi' => 2,
 174                         'hype' => 2,
 175                         'lol' => 2,
 176                         'love' => 2,
 177                         'number' => 2,
 178                         'pog' => 2,
 179                         'o7' => 2,
 180                         'wtf' => 2,
 181                 ];
 182                 $time_quotas = [
 183                         'gg' => 600,
 184                         'gl' => 900,
 185                         'hi' => 60,
 186                         'hype' => 60,
 187                         'lol' => 60,
 188                         'love' => 60,
 189                         'number' => 300,
 190                         'pog' => 60,
 191                         'o7' => 300,
 192                         'wtf' => 60,
 193                 ];
 194                 foreach ($classifications as $classification => $count) {
 195                         if ($classification == $last) continue;
 196                         if (!isset($count_quotas[$classification]) || $count < $count_quotas[$classification]) continue;
 197                         if (!isset($time_quotas[$classification]) || $this->getTimeSinceSpecial($channel, $classification) < $time_quotas[$classification]) continue;
 198                         $this->tagChannelSpecialSent($channel, $classification);
 199                         $reaction = $this->getChimeInReaction($channel, $classification);
 200                         return $this->getRandomOfClass($channel, $reaction);
 201                 }
 202                 return false;
 203         }
 204
 205         private function randomChat(Channel $channel) {
 206                 return $channel->queryChatlog()
 207                         ->whereNotIn('classification', ['gg', 'gl', 'number', 'o7'])
 208                         ->first();
 209         }
 210
 211         private function randomContextualNumber(Channel $channel) {
 212                 $notes = $this->getNotes($channel);
 213                 $min = 100000;
 214                 $max = 0;
 215                 foreach ($notes['latest_msgs'] as $msg) {
 216                         if ($msg->classify() == 'number') {
 217                                 $number = $msg->getNumericValue();
 218                                 $min = min($min, $number);
 219                                 $max = max($max, $number);
 220                         }
 221                 }
 222                 return random_int($min, $max);
 223         }
 224
 225         private function randomLaughter(Channel $channel) {
 226                 if (!random_int(0, 2)) {
 227                         return $channel->randomOfClass('lol');
 228                 }
 229                 return Arr::random([
 230                         ':tf:',
 231                         '4Head',
 232                         'CarlSmile',
 233                         'CruW',
 234                         'DendiFace',
 235                         'EleGiggle',
 236                         'GunRun',
 237                         'heh',
 238                         'Hhhehehe',
 239                         'Jebaited',
 240                         'Jebasted',
 241                         'KEKW',
 242                         'KEKHeim',
 243                         'KKona',
 244                         'KomodoHype',
 245                         'MaxLOL',
 246                         'MingLee',
 247                         'lol',
 248                         'LOL!',
 249                         'LUL',
 250                         'OneHand',
 251                         'SeemsGood',
 252                         'ShadyLulu',
 253                         'SoonerLater',
 254                         'SUBprise',
 255                         'xD',
 256                         'YouDontSay',
 257                 ]);
 258         }
 259
 260         private function randomMsg(Channel $channel) {
 261                 return $channel->queryChatlog()->first();
 262         }
 263
 264         private function performAdlib(Channel $channel) {
 265                 $db = $this->getChatlibDatabase($channel);
 266                 $latest_msg = $this->getLatestMessage($channel);
 267                 $text = $db->generate($latest_msg->getText());
 268                 $this->tagChannelWrite($channel);
 269                 $this->sendIRCMessage(IRCMessage::privmsg($channel->twitch_chat, $text));
 270                 $log = new ChatBotLog();
 271                 $log->channel()->associate($channel);
 272                 $log->category = 'adlib';
 273                 $log->text = $text;
 274                 $log->save();
 275         }
 276
 277         private function randomWaitMsgs(Channel $channel) {
 278                 $min = $channel->getChatSetting('wait_msgs_min', 1);
 279                 $max = $channel->getChatSetting('wait_msgs_max', 10);
 280                 return random_int($min, $max);
 281         }
 282
 283         private function randomWaitTime(Channel $channel) {
 284                 $min = $channel->getChatSetting('wait_time_min', 1);
 285                 $max = $channel->getChatSetting('wait_time_max', 900);
 286                 return random_int($min, $max);
 287         }
 288
 289         private function queueSpecial(Channel $channel, $classification) {
 290                 $this->getNotes($channel);
 291                 $this->notes[$channel->id]['queued_special'] = $classification;
 292         }
 293
 294         private function hasQueuedSpecial(Channel $channel) {
 295                 return !!$this->getQueuedSpecial($channel);
 296         }
 297
 298         private function getQueuedSpecial(Channel $channel) {
 299                 $notes = $this->getNotes($channel);
 300                 return $notes['queued_special'];
 301         }
 302
 303         private function clearQueuedSpecial(Channel $channel) {
 304                 $this->getNotes($channel);
 305                 $this->notes[$channel->id]['queued_special'] = false;
 306         }
 307
 308         private function tagChannelRead(Channel $channel, IRCMessage $msg) {
 309                 $this->getNotes($channel);
 310                 $this->notes[$channel->id]['last_read'] = time();
 311                 ++$this->notes[$channel->id]['read_since_last_write'];
 312
 313                 $tokenized = $msg->tokenize();
 314                 if (!ChatLog::isKnownBot($msg->nick) && !$tokenized->isSpammy()) {
 315                         $this->noteChannelMessage($channel, $tokenized);
 316                 }
 317                 if ($this->isDirectedAtMe($msg->getText()) && $this->shouldRespond($channel)) {
 318                         $this->noteChannelMessage($channel, $tokenized);
 319                         $this->notes[$channel->id]['wait_msgs'] = 0;
 320                         $this->notes[$channel->id]['wait_time'] = 0;
 321                         $response = $tokenized->getResponseCategory();
 322                         if ($response) {
 323                                 $this->queueSpecial($channel, $response);
 324                         }
 325                 }
 326         }
 327
 328         private function noteChannelMessage(Channel $channel, TokenizedMessage $tokenized) {
 329                 $this->notes[$channel->id]['latest_msgs'][] = $tokenized;
 330                 if (count($this->notes[$channel->id]['latest_msgs']) > 10) {
 331                         array_shift($this->notes[$channel->id]['latest_msgs']);
 332                 }
 333         }
 334
 335         private function tagChannelWrite(Channel $channel) {
 336                 $this->getNotes($channel);
 337                 $this->notes[$channel->id]['last_write'] = time();
 338                 $this->notes[$channel->id]['read_since_last_write'] = 0;
 339                 $this->notes[$channel->id]['wait_msgs'] = $this->randomWaitMsgs($channel);
 340                 $this->notes[$channel->id]['wait_time'] = $this->randomWaitTime($channel);
 341         }
 342
 343         private function tagChannelSpecialSent(Channel $channel, $classification) {
 344                 $this->getNotes($channel);
 345                 $this->notes[$channel->id]['last_special'][$classification] = time();
 346         }
 347
 348         private function getLatestMessage(Channel $channel) {
 349                 $notes = $this->getNotes($channel);
 350                 if (!empty($notes['latest_msgs'])) {
 351                         return $notes['latest_msgs'][count($notes['latest_msgs']) - 1];
 352                 }
 353                 return TokenizedMessage::fromString('');
 354         }
 355
 356         private function getLastSpecialSent(Channel $channel) {
 357                 $notes = $this->getNotes($channel);
 358                 $max_time = 0;
 359                 $max_classification = '';
 360                 foreach ($notes['last_special'] as $classification => $time) {
 361                         if ($time > $max_time) {
 362                                 $max_time = $time;
 363                                 $max_classification = $classification;
 364                         }
 365                 }
 366                 return $max_classification;
 367         }
 368
 369         private function getTimeSinceSpecial(Channel $channel, $classification) {
 370                 $notes = $this->getNotes($channel);
 371                 if (isset($notes['last_special'][$classification])) {
 372                         return time() - $notes['last_special'][$classification];
 373                 }
 374                 return 999999;
 375         }
 376
 377         private function isDirectedAtMe($raw_text) {
 378                 $text = strtolower($raw_text);
 379                 if (strpos($text, 'horsti') !== false) {
 380                         return true;
 381                 }
 382                 return false;
 383         }
 384
 385         private function shouldAdlib(Channel $channel) {
 386                 $setting = $channel->getChatSetting('adlib', 50);
 387                 if ($setting == 0) {
 388                         return false;
 389                 }
 390                 if ($setting == 100) {
 391                         return true;
 392                 }
 393                 return random_int(0, 100) <= $setting;
 394         }
 395
 396         private function shouldRespond(Channel $channel) {
 397                 $setting = $channel->getChatSetting('respond', 'yes');
 398                 if ($setting == 'yes') {
 399                         return true;
 400                 }
 401                 if ($setting == '50') {
 402                         return random_int(0, 1);
 403                 }
 404                 return false;
 405         }
 406
 407         private function getRandomOfClass(Channel $channel, $classification) {
 408                 if ($classification == 'number') {
 409                         return $this->randomContextualNumber($channel);
 410                 }
 411                 if ($classification == 'lol') {
 412                         return $this->randomLaughter($channel);
 413                 }
 414                 return $channel->randomOfClass($classification);
 415         }
 416
 417         private function getChimeInReaction(Channel $channel, $classification) {
 418                 switch ($classification) {
 419                         case 'hi':
 420                                 return ['hi', 'love'];
 421                         case 'hype':
 422                                 return ['hype', 'love', 'pog'];
 423                         case 'lol':
 424                                 return ['kappa', 'lol'];
 425                         case 'pog':
 426                                 return ['hype', 'pog'];
 427                         case 'wtf':
 428                                 return ['lol', 'wtf'];
 429                 }
 430                 return $classification;
 431         }
 432
 433         private $channels;
 434         private $notes = [];
 435         private $chatlib;
 436
 437 }