753 lines
28 KiB
Python
753 lines
28 KiB
Python
# -*- coding: utf-8 -*-
|
|
from irc3.plugins.command import command
|
|
import irc3
|
|
import os
|
|
import random
|
|
import ipdb
|
|
from random import randint
|
|
from re import compile
|
|
from irc3 import rfc
|
|
import subprocess
|
|
#ipdb.set_trace()
|
|
|
|
dir_path = os.path.dirname(os.path.realpath(__file__))
|
|
|
|
KRYPTR = []
|
|
BOTNAMES = []
|
|
BOTNICKS = []
|
|
TOTAL_BOTS = 0
|
|
READY_BOTS = []
|
|
LOCK_KRYLON = 1 # 1
|
|
INTERRUPTED = 0
|
|
|
|
|
|
global FIRST_EXEC
|
|
|
|
cp437 = {
|
|
0:'\u0000',1:'\u263A',2:'\u263B',3:'\u2665',4:'\u2666',5:'\u2663',6:'\u2660',7:'\u2022',
|
|
8:'\u25D8',9:'\u25CB',10:'\u25D9',11:'\u2642',12:'\u2640',13:'\u266A',14:'\u266B',15:'\u263C',
|
|
16:'\u25BA',17:'\u25C4',18:'\u2195',19:'\u203C',20:'\u00B6',21:'\u00A7',22:'\u25AC',23:'\u21A8',
|
|
24:'\u2191',25:'\u2193',26:'\u2192',27:'\u2190',28:'\u221F',29:'\u2194',30:'\u25B2',31:'\u25BC',
|
|
32:'\u0020',33:'\u0021',34:'\u0022',35:'\u0023',36:'\u0024',37:'\u0025',38:'\u0026',39:'\u0027',
|
|
40:'\u0028',41:'\u0029',42:'\u002A',43:'\u002B',44:'\u002C',45:'\u002D',46:'\u002E',47:'\u002F',
|
|
48:'\u0030',49:'\u0031',50:'\u0032',51:'\u0033',52:'\u0034',53:'\u0035',54:'\u0036',55:'\u0037',
|
|
56:'\u0038',57:'\u0039',58:'\u003A',59:'\u003B',60:'\u003C',61:'\u003D',62:'\u003E',63:'\u003F',
|
|
64:'\u0040',65:'\u0041',66:'\u0042',67:'\u0043',68:'\u0044',69:'\u0045',70:'\u0046',71:'\u0047',
|
|
72:'\u0048',73:'\u0049',74:'\u004A',75:'\u004B',76:'\u004C',77:'\u004D',78:'\u004E',79:'\u004F',
|
|
80:'\u0050',81:'\u0051',82:'\u0052',83:'\u0053',84:'\u0054',85:'\u0055',86:'\u0056',87:'\u0057',
|
|
88:'\u0058',89:'\u0059',90:'\u005A',91:'\u005B',92:'\u005C',93:'\u005D',94:'\u005E',95:'\u005F',
|
|
96:'\u0060',97:'\u0061',98:'\u0062',99:'\u0063',100:'\u0064',101:'\u0065',102:'\u0066',103:'\u0067',
|
|
104:'\u0068',105:'\u0069',106:'\u006A',107:'\u006B',108:'\u006C',109:'\u006D',110:'\u006E',111:'\u006F',
|
|
112:'\u0070',113:'\u0071',114:'\u0072',115:'\u0073',116:'\u0074',117:'\u0075',118:'\u0076',119:'\u0077',
|
|
120:'\u0078',121:'\u0079',122:'\u007A',123:'\u007B',124:'\u007C',125:'\u007D',126:'\u007E',127:'\u2302',
|
|
128:'\u00C7',129:'\u00FC',130:'\u00E9',131:'\u00E2',132:'\u00E4',133:'\u00E0',134:'\u00E5',135:'\u00E7',
|
|
136:'\u00EA',137:'\u00EB',138:'\u00E8',139:'\u00EF',140:'\u00EE',141:'\u00EC',142:'\u00C4',143:'\u00C5',
|
|
144:'\u00C9',145:'\u00E6',146:'\u00C6',147:'\u00F4',148:'\u00F6',149:'\u00F2',150:'\u00FB',151:'\u00F9',
|
|
152:'\u00FF',153:'\u00D6',154:'\u00DC',155:'\u00A2',156:'\u00A3',157:'\u00A5',158:'\u20A7',159:'\u0192',
|
|
160:'\u00E1',161:'\u00ED',162:'\u00F3',163:'\u00FA',164:'\u00F1',165:'\u00D1',166:'\u00AA',167:'\u00BA',
|
|
168:'\u00BF',169:'\u2310',170:'\u00AC',171:'\u00BD',172:'\u00BC',173:'\u00A1',174:'\u00AB',175:'\u00BB',
|
|
176:'\u2591',177:'\u2592',178:'\u2593',179:'\u2502',180:'\u2524',181:'\u2561',182:'\u2562',183:'\u2556',
|
|
184:'\u2555',185:'\u2563',186:'\u2551',187:'\u2557',188:'\u255D',189:'\u255C',190:'\u255B',191:'\u2510',
|
|
192:'\u2514',193:'\u2534',194:'\u252C',195:'\u251C',196:'\u2500',197:'\u253C',198:'\u255E',199:'\u255F',
|
|
200:'\u255A',201:'\u2554',202:'\u2569',203:'\u2566',204:'\u2560',205:'\u2550',206:'\u256C',207:'\u2567',
|
|
208:'\u2568',209:'\u2564',210:'\u2565',211:'\u2559',212:'\u2558',213:'\u2552',214:'\u2553',215:'\u256B',
|
|
216:'\u256A',217:'\u2518',218:'\u250C',219:'\u2588',220:'\u2584',221:'\u258C',222:'\u2590',223:'\u2580',
|
|
224:'\u03B1',225:'\u00DF',226:'\u0393',227:'\u03C0',228:'\u03A3',229:'\u03C3',230:'\u00B5',231:'\u03C4',
|
|
232:'\u03A6',233:'\u0398',234:'\u03A9',235:'\u03B4',236:'\u221E',237:'\u03C6',238:'\u03B5',239:'\u2229',
|
|
240:'\u2261',241:'\u00B1',242:'\u2265',243:'\u2264',244:'\u2320',245:'\u2321',246:'\u00F7',247:'\u2248',
|
|
248:'\u00B0',249:'\u2219',250:'\u00B7',251:'\u221A',252:'\u207F',253:'\u00B2',254:'\u25A0',255:'\u00A0',
|
|
}
|
|
|
|
class D():
|
|
def __init__(self):
|
|
self.MODE_BOLD=0
|
|
return
|
|
def c(self,n):
|
|
n = int(n)
|
|
cc = {
|
|
99:'\x03',
|
|
1:'\x02', #bold
|
|
3:'\x1d', #italics
|
|
4:'\x1f', #underline
|
|
9:'\x1e', #strikethrough
|
|
0:'\x01',
|
|
40:'1',
|
|
|
|
30:'14',
|
|
31:'04',
|
|
32:'09',
|
|
33:'08',
|
|
34:'12',
|
|
35:'13',
|
|
36:'11',
|
|
37:'15',
|
|
41:'04',
|
|
42:'09',
|
|
43:'08',
|
|
44:'12',
|
|
45:'13',
|
|
46:'11',
|
|
47:'15'
|
|
}
|
|
|
|
cb = {
|
|
99:'\x03',
|
|
1:'\x02', #bold
|
|
3:'\x1d', #italics
|
|
4:'\x1f', #underline
|
|
9:'\x1e', #strikethrough
|
|
0:'\x01',
|
|
40:'1',
|
|
|
|
30:'14',
|
|
31:'28',
|
|
32:'09',
|
|
33:'54',
|
|
34:'72',
|
|
35:'13',
|
|
36:'11',
|
|
37:'15',
|
|
41:'04',
|
|
42:'09',
|
|
43:'08',
|
|
44:'12',
|
|
45:'13',
|
|
46:'11',
|
|
47:'15'
|
|
}
|
|
|
|
#ipdb.set_trace()
|
|
if self.MODE_BOLD==1:
|
|
if n >= 30 and n <= 47:
|
|
return int(cc[n])
|
|
else:
|
|
return cb[n]
|
|
else:
|
|
return cb[n]
|
|
|
|
class KRYLON():
|
|
|
|
def __init__(self,bot,channel):
|
|
|
|
self.KRYLON_FILE = []
|
|
self.bot = bot
|
|
self.channel = channel
|
|
#self.KRYLON_FILE = ['a'*40,'b'*40,'c'*40,'d'*40,'e'*40,'f'*40,'g'*40,'h'*40,'1'*40,'2'*40,'3'*40,'4'*40,'5'*40,'6'*40,'7'*40,'8'*40]
|
|
#ipdb.set_trace()
|
|
self.__run__()
|
|
|
|
def q(self,s):
|
|
#f = open('/home/dr1p/.weechat/weechat_fifo','w')
|
|
#f.write('*{}\x0a'.format(s))
|
|
#f.close()
|
|
#f = open('/home/dr1p/Documents/code/python/krylon/test.txt','a')
|
|
#f.write('*{}\x0a'.format(s))
|
|
#f.close()
|
|
self.KRYLON_FILE.append(s)
|
|
|
|
def w(self,s,index):
|
|
d=D()
|
|
s = s.replace('\x1b','')
|
|
ss = s
|
|
codes=[]
|
|
ogcodes=[]
|
|
newcodes=[]
|
|
while True:
|
|
sa = ss.find('[')
|
|
sb = ss.find('m')
|
|
if sa == -1 and sb == -1:
|
|
break
|
|
x = ss[sa:sb+1]
|
|
ogcodes.append(x)
|
|
codes.append(x.replace('m','').replace('[','').split(';'))
|
|
ss=ss[sb+1:]
|
|
count = len(codes[-1])
|
|
if count == 1:
|
|
ca = codes[-1][0]
|
|
if ca == '1' or ca == '3' or ca == '4' or ca == '9':
|
|
if ca == '1':
|
|
code = "{}".format(d.c(99))
|
|
else:
|
|
code = "{}".format(d.c(ca))
|
|
elif ca == '0':
|
|
code = "{}".format(d.c(1))
|
|
elif ca == '31':
|
|
# d.MODE_BOLD=0
|
|
code = "{}{}".format(d.c(99),d.c(31))
|
|
else:
|
|
try:
|
|
code = "{}{}".format(d.c(99),d.c(ca))
|
|
#code = "{},{}".format(c[99],c[int(ca)])
|
|
except:
|
|
if ca == '7C1':
|
|
codes[-1]=1
|
|
|
|
newcodes.append(code)
|
|
elif count == 2:
|
|
ca = codes[-1][0]
|
|
cb = codes[-1][1]
|
|
# ipdb.set_trace()
|
|
if ca == '0':
|
|
d.MODE_BOLD=0
|
|
code = "{}{}".format(d.c(99),d.c(cb))
|
|
elif ca == '1':
|
|
d.MODE_BOLD=1
|
|
code = "{}{}".format(d.c(99),d.c(cb))
|
|
else:
|
|
code = "{}{}{}{}".format(d.c(99),d.c(ca),d.c(99),d.c(cb))
|
|
|
|
newcodes.append(code)
|
|
elif count == 3:
|
|
ca = codes[-1][0]
|
|
cb = codes[-1][1]
|
|
cc = codes[-1][1]
|
|
if ca == '0':
|
|
code = "{}{},{}".format(d.c(99),d.c(cb),d.c(cc))
|
|
elif ca == '1':
|
|
d.MODE_BOLD=1
|
|
code = "{}{}{}{}".format(d.c(99),d.c(cb),d.c(99),d.c(cc))
|
|
newcodes.append(code)
|
|
|
|
elif count == 4:
|
|
ca = codes[-1][0]
|
|
cb = codes[-1][1]
|
|
cc = codes[-1][2]
|
|
cd = codes[-1][3]
|
|
code = "{}{}{},{}".format(d.c(1),d.c(99),d.c(cd),d.c(cc))
|
|
newcodes.append(code)
|
|
|
|
buffer = s
|
|
for i,_ in enumerate(ogcodes):
|
|
z = buffer.find(_)
|
|
if z == 0:
|
|
b=buffer[len(_):]
|
|
a=newcodes[i]
|
|
buffer = "{}{}".format(a,b)
|
|
else:
|
|
try:
|
|
a=buffer[:buffer.find(_)]
|
|
b=newcodes[i]
|
|
c=buffer[buffer.find(_)+len(ogcodes[i]):]
|
|
buffer = "{}{}{}".format(a,b,c)
|
|
except:
|
|
print('hi')
|
|
ipdb.set_trace()
|
|
print('hi')
|
|
print('hi')
|
|
self.q(buffer)
|
|
|
|
|
|
|
|
def __run__(self):
|
|
|
|
try:
|
|
if int(FIRST_EXEC) == 0:
|
|
print('yolo')
|
|
except:
|
|
#ipdb.set_trace()
|
|
FIRST_EXEC = 1
|
|
self.__f = open('/home/dr1p/Documents/code/python/krylon/acid.txt','r')
|
|
self.__l = self.__f.read().splitlines()
|
|
self.__f.close()
|
|
|
|
for i,_ in enumerate(self.__l):
|
|
if _.find('\x1aSAUCE') == -1:
|
|
self.w(_,i)
|
|
else:
|
|
pass
|
|
|
|
self.KRYLON_FILE.reverse()
|
|
self.FILE_BUFFER=[]
|
|
for _ in self.KRYLON_FILE:
|
|
self.FILE_BUFFER.append(_)
|
|
self.FILE_LINES = len(self.KRYLON_FILE)
|
|
self.INIT = 0
|
|
self.STARTED = 0
|
|
self.FINISHED = 0
|
|
self.FILE_INDEX = 0
|
|
# BITWISE FILE LOCK SET
|
|
self.KRYLON_FILE_LOCK = []
|
|
for _ in range(len(self.KRYLON_FILE)):
|
|
self.KRYLON_FILE_LOCK.append(1)
|
|
# BITWISE R/W BOT LOCK SET
|
|
self.BOTS_MODE_LOCK = []
|
|
for _ in range(len(READY_BOTS)):
|
|
self.BOTS_MODE_LOCK.append(zip('1','1'))
|
|
# BITWISE R/W BOT LOCK UNSET
|
|
R=[]; W=[]; _X=-1; _Y=-1;
|
|
for _ in range(len(READY_BOTS)):
|
|
_X,_Y=list(self.BOTS_MODE_LOCK[_])[0]
|
|
R.append(int(_X))
|
|
W.append(int(_Y))
|
|
self.BOTS_MODE_READ=R
|
|
self.BOTS_MODE_WRIT=W
|
|
|
|
@irc3.plugin
|
|
class Plugin(object):
|
|
|
|
def __init__(self, context):
|
|
self.log = context.log
|
|
self.context = context
|
|
self.channel = context.config.channel
|
|
self._ST8 = 0
|
|
|
|
def __emoj(self,s):
|
|
emote_db = '%s/emote.db' % dir_path
|
|
emoj = random.choice(list(open(emote_db)))
|
|
random.randint(0,1)
|
|
if random.randint(0,1) == 0:
|
|
emoj = "\x0304{}\x0F".format(emoj)
|
|
else:
|
|
emoj = "\x0303{}\x0F".format(emoj)
|
|
s = s + ' ▶ ' + emoj
|
|
return s
|
|
|
|
def __greet(self):
|
|
greet_db = '%s/greet.db' % dir_path
|
|
greet = random.choice(list(open(greet_db)))
|
|
return greet
|
|
|
|
def __symbol(self):
|
|
symbol_db = '%s/symbol.db' % dir_path
|
|
symbol = random.choice(list(open(symbol_db)))
|
|
return symbol
|
|
|
|
def rotate(self):
|
|
self.b1n+=1
|
|
if self.b1n == len(BOTNICKS):
|
|
self.b1n=0
|
|
ipdb.set_trace()
|
|
|
|
def spraying(self, mask, channel, **kw):
|
|
|
|
PTR = KRYPTR[0]
|
|
PTR.kbr = []; PTR.kbw = []; PTR.kbl = [];
|
|
PTR.chn = channel
|
|
|
|
for index in range(len(PTR.BOTS_MODE_READ)):
|
|
PTR.kbr.append(PTR.BOTS_MODE_READ[index])
|
|
PTR.kbw.append(PTR.BOTS_MODE_WRIT[index])
|
|
PTR.kbl.append(PTR.KRYLON_FILE_LOCK[index])
|
|
|
|
PTR.fbu = PTR.FILE_BUFFER
|
|
PTR.fli = PTR.FILE_LINES
|
|
PTR.fin = PTR.FILE_INDEX
|
|
BOTNAMES=','.join(self.context.config.botnet.keys()).split(',')
|
|
PTR.bna = BOTNAMES
|
|
BOTNICKS=[]
|
|
for _ in BOTNAMES:
|
|
BOTNICKS.append(self.context.config.botnet[_].nick)
|
|
PTR.bni = BOTNICKS
|
|
PTR.b1n = BOTNICKS.index(self.context.nick)
|
|
PTR.int = 0
|
|
|
|
if PTR.INIT == 0:
|
|
PTR._ST8 = 0
|
|
PTR.INIT = 1
|
|
print('<<<<<<> JUST INIT <>>>>>>') # test if initialized for first pass, fails on purpose
|
|
PTR.STARTED = 1
|
|
PTR.FINISHED = 0
|
|
PTR.exe = 1 # set to recognize execution
|
|
PTR.cyc = 0 # how many cycles within this operation, e.g. amount of bots pass through this function
|
|
PTR.ops = 0 # how many completed operations, cycles reset, ops continue to count
|
|
|
|
#ipdb.set_trace()
|
|
|
|
for y in range(len(PTR.bni)):
|
|
if not y == PTR.b1n:
|
|
PTR.kbr[y] = 0
|
|
else:
|
|
PTR.kbw[y] = 1
|
|
|
|
PTR.who = self.context.nick
|
|
MSG=PTR.fbu.pop()
|
|
PTR.what = MSG
|
|
PTR.fin+=1
|
|
NEWBOT=','.join(list(self.context.config.botnet.keys())).split(',')[PTR.b1n]
|
|
print(PTR.bni)
|
|
print(PTR.bna)
|
|
print(PTR.b1n)
|
|
print(PTR.bni[PTR.b1n])
|
|
print(PTR.bna[PTR.b1n])
|
|
print("WHO:{} NEWBOT:{}".format(PTR.who,NEWBOT))
|
|
self.context.privmsg(PTR.chn,MSG)
|
|
|
|
if PTR._ST8 <= 5 and PTR.FINISHED == 1:
|
|
PTR.int = INTERRUPTED
|
|
INTERRUPTED = 0
|
|
PTR._ST8 = 3
|
|
|
|
@irc3.event(irc3.rfc.JOIN)
|
|
def welcome(self, mask, channel, **kw):
|
|
|
|
if LOCK_KRYLON == 1:
|
|
B0T = self.context
|
|
B0TNAMES=','.join(self.context.config.botnet.keys()).split(',')
|
|
B0TN1CKS=[]
|
|
for _ in B0TNAMES:
|
|
B0TN1CKS.append(self.context.config.botnet[_].nick)
|
|
|
|
for i,B0T.nick in enumerate(B0TN1CKS):
|
|
if B0TN1CKS[i] == B0T.nick:
|
|
NFLAG=1
|
|
for _ in READY_BOTS:
|
|
if B0T.nick == _:
|
|
NFLAG=0
|
|
|
|
if NFLAG==1:
|
|
READY_BOTS.append(self.context.nick)
|
|
BOTCNT = len(self.context.config.botnet)
|
|
|
|
if len(READY_BOTS) == BOTCNT:
|
|
BOTNICKS=B0TN1CKS
|
|
BOTNAMES=B0TNAMES
|
|
TOTAL_BOTS = BOTCNT;
|
|
BOT=self.context
|
|
CHN=channel
|
|
k=KRYLON(BOT,CHN)
|
|
KRYPTR.append(k)
|
|
self.spraying(mask,channel,**kw)
|
|
|
|
@irc3.event(irc3.rfc.CONNECTED)
|
|
def connected(self, **kw):
|
|
|
|
if LOCK_KRYLON == 1:
|
|
self.context.join(self.channel)
|
|
|
|
|
|
@irc3.event(rfc.PRIVMSG, iotype="out")
|
|
def krylon_event(bot, mask=None, event=None, target=None, data=None):
|
|
NICK=bot.context.nick
|
|
CHANNEL=bot.channel
|
|
MSG="CHANNEL: {} event out: {}".format(CHANNEL,NICK)
|
|
print(MSG)
|
|
# ipdb.set_trace()
|
|
PTR = KRYPTR[0]
|
|
B0T=bot.context
|
|
B1N = PTR.bni.index(B0T.nick)
|
|
|
|
print("OUTPUT:{}".format(bot.context.nick))
|
|
|
|
# if PTR.who == bot.context.nick and PTR.STARTED == 1 and PTR.FINISHED == 0 and PTR.what == data and PTR.fin < PTR.fli:
|
|
|
|
|
|
# PTR.fin+=1
|
|
# PTR.b1n+=1
|
|
# if PTR.b1n == len(PTR.bni):
|
|
# PTR.b1n=0
|
|
|
|
|
|
# PTR.who = PTR.bni[PTR.b1n]
|
|
# MSG=PTR.fbu.pop()
|
|
# PTR.what = MSG
|
|
# NEWBOT=','.join(list(bot.context.config.botnet.keys())).split(',')[PTR.b1n]
|
|
# print(NEWBOT)
|
|
# ipdb.set_trace()
|
|
# bot.context.privmsg(CHANNEL,MSG)
|
|
# bot.context.config.botnet[NEWBOT].privmsg(CHANNEL,MSG)
|
|
# ipdb.set_trace()
|
|
|
|
# ipdb.set_trace()
|
|
|
|
|
|
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# # ipdb.set_trace()
|
|
# MSG+=" (BOT)NICK/NAME:{}/{} <> ".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{} ".format(bot.kbl[B1N],bot.kbr[B1N],bot.kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(bot.fli,bot.fin,bot.int)
|
|
# bot.context.privmsg(CHANNEL,MSG)
|
|
|
|
|
|
|
|
#bot.context.privmsg(CHANNEL,"{} event out".format(NICK))
|
|
|
|
|
|
@irc3.event(irc3.rfc.PRIVMSG, iotype="in")
|
|
def on_privmsg(self, mask=None, data=None, **kw):
|
|
|
|
# B0T=self.context
|
|
|
|
# print(data)
|
|
bot = self
|
|
NICK=bot.context.nick
|
|
CHANNEL=bot.channel
|
|
MSG="CHANNEL: {} event out: {}".format(CHANNEL,NICK)
|
|
print(MSG)
|
|
# ipdb.set_trace()
|
|
PTR = KRYPTR[0]
|
|
B0T=bot.context
|
|
B1N = PTR.bni.index(B0T.nick)
|
|
|
|
print("INPUT:{}".format(bot.context.nick))
|
|
|
|
WTF=0
|
|
|
|
if mask.nick == 'd' and PTR.int == 0:
|
|
self.context.privmsg('#sh0rtbus','dont interrupt me mofo')
|
|
PTR.int = 1
|
|
PTR.FILE_BUFFER=[]
|
|
for _ in PTR.KRYLON_FILE:
|
|
PTR.FILE_BUFFER.append(_)
|
|
PTR.fbu = PTR.FILE_BUFFER
|
|
PTR.INIT = 0
|
|
PTR.fin=0
|
|
PTR.b1n=0
|
|
self.spraying(mask,channel,**kw)
|
|
return
|
|
|
|
if PTR.who == mask.nick and PTR.STARTED == 1 and PTR.FINISHED == 0 and PTR.what == data and PTR.fin < PTR.fli:
|
|
|
|
|
|
PTR.fin+=1
|
|
PTR.b1n+=1
|
|
if PTR.b1n == len(PTR.bni):
|
|
PTR.b1n=0
|
|
|
|
PTR.who = PTR.bni[PTR.b1n]
|
|
MSG=PTR.fbu.pop()
|
|
PTR.what = MSG
|
|
NEWBOT=','.join(list(bot.context.config.botnet.keys())).split(',')[PTR.b1n]
|
|
print(NEWBOT)
|
|
bot.context.config.botnet[NEWBOT].privmsg(CHANNEL,MSG)
|
|
|
|
|
|
|
|
# self.BYPASSING=0
|
|
# if mask.nick == 'd': self.BYPASSING=1
|
|
|
|
# if self._ST8 == 2:
|
|
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< initial complications getting into the areas to do art ops, a server/channel/max-limit/key or invite only type issue >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 >= 3 or self.BYPASSING == 1:
|
|
|
|
# NOTBOT=0
|
|
# B0T = self.context
|
|
# CHN = B0T.config.channel
|
|
# try:
|
|
# B1N = BOTNICKS.index(B0T.nick)
|
|
# except:
|
|
# pass
|
|
|
|
# if not mask.nick == B0T.nick:
|
|
# NOTBOT=1
|
|
# if KRYPTR[0].STARTED == 1 and KRYPTR[0].FINISHED == 0:
|
|
# if not self._fli <=0:
|
|
# self.INTERRUPTED+=1
|
|
# rando = random.randint(1,5)
|
|
# MSG=''
|
|
# if rando == 1:
|
|
# MSG+='no cellphones plz'
|
|
# elif rando == 2:
|
|
# MSG+='mind being quiet?'
|
|
# elif rando == 3:
|
|
# MSG+='trying to do something here...'
|
|
# elif rando == 4:
|
|
# MSG+='have you seen this before?'
|
|
# elif rando == 5:
|
|
# MSG+='there could be a secret message'
|
|
# self.context.privmsg(CHN,MSG)
|
|
# KRYPTR[0].FILE_BUFFER=KRYPTR[0].KRYLON_FILE
|
|
# KRYPTR[0].FILE_LINES = len(KRYPTR[0].KRYLON_FILE)
|
|
# KRYPTR[0].FILE_INDEX = 0
|
|
# self.spraying(mask,self.channel,**kw)
|
|
# self._ST8 = 5
|
|
# else:
|
|
# NOTBOT=0
|
|
# if self._ST8 == 3:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< ART OP SIMULATION >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 4:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< done with no interruptions >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 5:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MENTALITY=self.INTERRUPTED
|
|
# DIAGNOSIS=''
|
|
# if MENTALITY < 3:
|
|
# DIAGNOSIS='mild'
|
|
# elif MENTALITY > 5 and mentality < 10:
|
|
# DIAGNOSIS='notice me notice me type,'
|
|
# elif MENTALITY > 10 and MENTALITY <= 20:
|
|
# DIAGNOSIS='jack hoffish and almost k00nt like'
|
|
# elif MENTALITY > 35 and MENTALITY < 50:
|
|
# DIAGNOSIS='almost twitter/facbook/google type censorship'
|
|
# elif MENTALITY >= 50:
|
|
# DIAGNOSIS='semi-stalkerish, you know... probably have not even received their actual valentine card yet. definitely got lost in the mail im sure but hey, show on this teddy bear where this artwork hurts you kind of'
|
|
# MSG="<< done with some {} interruptions >>".format(DIAGNOSIS)
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 6:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< someone or something is inihibiting the operations, we may not finish the op >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 7:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< im now offended and attacking the source of the problems, probably not gonna go well >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 8:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< finshed the op but people are definitely gonna be pissed >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
# if self._ST8 == 9:
|
|
# for i,B0T.nick in enumerate(BOTNICKS):
|
|
# if BOTNICKS[i] == B0T.nick:
|
|
# MSG="<< being shunted by forces of an administration access. failsafed and self-shutting down >>"
|
|
# #redundant code//change later
|
|
# MSG+="(BOT)NICK/NAME:{}/{} <>".format(BOTNICKS[i],BOTNAMES[i])
|
|
# MSG+="LOCK:{} READ:{} WRITE:{}".format(self._kbl[B1N],self._kbr[B1N],self._kbw[B1N])
|
|
# MSG+="LINES:{} INDEX:{} INTERRUPTED:{}".format(self._fli,self._fin,self._int)
|
|
# self.context.privmsg(CHN,MSG)
|
|
|
|
|
|
# """
|
|
# @irc3.event(rfc.ERR_BADCHANNELKEY)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_BANNEDFROMCHAN)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_CANNOTSENDTOCHAN)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_CHANNELISFULL)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOPRIVILEGES)
|
|
# def myevent(bot, srv=None, me=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOSUCHCHANNEL)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOSUCHCHANNEL)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOTONCHANNEL)
|
|
# def myevent(bot, srv=None, me=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.CTCP, iotype="out")
|
|
# def myevent(bot, event=None, target=None, ctcp=None):
|
|
|
|
# @irc3.event(rfc.INVITE)
|
|
# def myevent(bot, mask=None, channel=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.JOIN)
|
|
# def myevent(bot, mask=None, channel=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.JOIN_PART_QUIT, iotype="out")
|
|
# def myevent(bot, event=None, channel=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.KICK)
|
|
# def myevent(bot, mask=None, event=None, channel=None, target=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.MODE)
|
|
# def myevent(bot, mask=None, event=None, target=None, modes=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.MY_PRIVMSG)
|
|
# def myevent(bot, mask=None, event=None, target=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.NEW_NICK, iotype="out")
|
|
# def myevent(bot, new_nick=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.PING)
|
|
# def myevent(bot, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.PONG)
|
|
# def myevent(bot, server=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.PRIVMSG)
|
|
# def myevent(bot, mask=None, event=None, target=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.QUIT, iotype="out")
|
|
# def myevent(bot, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.TOPIC)
|
|
# def myevent(bot, mask=None, channel=None, data=None, tags=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_ALREADYREGISTRED)
|
|
# def myevent(bot, srv=None, me=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOTREGISTERED)
|
|
# def myevent(bot, srv=None, me=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_ERRONEUSNICKNAME)
|
|
# def myevent(bot, srv=None, me=None, nick=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_NOLOGIN)
|
|
# def myevent(bot, srv=None, me=None, nick=None, data=None):
|
|
# # do something
|
|
|
|
# @irc3.event(rfc.ERR_PASSWDMISMATCH)
|
|
# def myevent(bot, srv=None, me=None, data=None):
|
|
# # do something
|
|
# """sohttps://www.amazon.com/Bedsure-Sweatshirt-Wearable-Families-Standard/
|