def onServerUpdatedEvent(self, schid):
if not self.requested: return
self.requested = False
self.timers[schid] = QTimer()
self.timers[schid].timeout.connect(self.tick)
interval = calculateInterval(schid, AntiFloodPoints.CLIENTUPDATE, self.name)
self.timers[schid].start(interval)
def restoreTabs(self):
try:
err, schids = ts3lib.getServerConnectionHandlerList()
if err != ERROR_ok: return
if len(schids) > 1: return
for schid in schids:
(err, status) = ts3lib.getConnectionStatus(schid)
if err != ERROR_ok: return
if status != ConnectStatus.STATUS_DISCONNECTED: return
self._tabs = {}
self._timers = []
with open(self.backup_file) as f:
self._tabs = load(f)
i = 0
self._delay = self.delay
for tab in self._tabs:
i += 1
# if self._tabs[tab]["status"] == ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
timer = QTimer()
self._timers.append(timer)
timer.singleShot(self._delay, self.restoreTab)
# self.restoreTab(tab)
self._delay += self.increase
except:
ts3lib.logMessage(format_exc(), LogLevel.LogLevel_ERROR, "pyTSon",
0)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if menuItemID == 0:
if self.timer is None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.timer.isActive():
self.timer.stop()
self.timer = None
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME,
self.nick)
ts3lib.flushClientSelfUpdates(schid)
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
(err, nick) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
if len(nick) > self.max - 2:
errorMsgBox(
"Error",
"Nickname must be %s chars or below!" % self.max)
return
self.nick = nick
self._nick = list(nick)
self.i = self.max - 2
self.b = 0
self.schid = schid
step = inputBox(self.name, 'Interval in Milliseconds:')
if step: interval = int(step)
else: interval = 300
self.timer.start(interval)
ts3lib.printMessageToCurrentTab('Timer started!')
class guestLounge(ts3plugin):
path = getScriptPath(__name__)
name = "Guest Lounges"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = ""
offersConfigure = False
commandKeyword = ""
infoTitle = None
hotkeys = []
menuItems = []
timer = QTimer()
ts3host = None
"""
cfg = ConfigParser()
cfg["9lBVIDJRSSgAGy+cWJgNlUQRd64="] = { "enabled": True }
"""
def __init__(self):
if "aaa_ts3Ext" in PluginHost.active:
ts3ext = PluginHost.active["aaa_ts3Ext"]
self.ts3host = ts3ext.ts3host
self.tabs = ts3ext.tabs
else:
retry = 1000
self.timer.singleShot(retry, self.__init__)
ts3lib.printMessageToCurrentTab("{}: [color=red]Dependency not yet loaded, retrying in {} second(s)!".format(self.name, retry/1000))
return
if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded.".format(timestamp(),self.name,self.author))
def stop(self):
if hasattr(self, "timer"):
if self.timer.isActive(): self.timer.stop()
del self.timer
def onClientMoveEvent(self, schid, clid, oldChannelID, newChannelID, visibility, moveMessage):
client = self.ts3host.getUser(schid, clid)
if client.server.me.channel.cid
if not client.server.me.getChannelGroupId() in [self.tabs[schid]["channelModGroup"], client.server.defaultChannelAdminGroup]: return
if clientID in self.waiting and (newChannelID == 0 or newChannelID == self.mychan):
# if newChannelID == self.mychan:
# (err, dbid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
ts3lib.printMessage(schid, "{}: [color=orange]Removing channel mod from {}".format(self.name, self.waiting[clientID] if newChannelID == 0 else clientURL(schid, clientID)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3lib.requestSetClientChannelGroup(schid, [self.sgid_guest], [self.mychan], [self.waiting[clientID]])
del self.waiting[clientID]
return
if newChannelID == 0 or oldChannelID != 0: return
(err, sgids) = ts3lib.getClientVariableAsString(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
if not self.sgid_guest in intList(sgids): return
# TODO Any way to get the cgid in another channel?
(err, uid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if getContactStatus(uid) == ContactStatus.BLOCKED:
ts3lib.printMessage(schid, "{}: [color=red]Not allowing blocked user {} in your channel.".format(self.name, clientURL(schid, clientID)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
return
(err, dbid) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
self.waiting[clientID] = dbid
ts3lib.printMessage(schid, "{}: [color=green]Found new guest {} giving him channel mod until he's here ;)".format(self.name, clientURL(schid, clientID)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
ts3lib.requestSetClientChannelGroup(schid, [self.cgid_mod], [self.mychan], [dbid])
def testBillboard(self):
avatar = naali.getUserAvatar()
avatar_pos = avatar.GetComponentRaw("EC_Placeable")
self.pixmap_label = QLabel()
self.pixmap_label.size = QSize(200, 200)
self.pixmap_label.scaledContents = True
self.pixmap_label.setPixmap(QPixmap('./data/ui/images/naali_icon.png'))
self.text_label = QLabel()
self.text_label.size = QSize(300, 50)
self.text_label.text = "Hello world"
self.my_widget = QWidget()
self.my_widget.setLayout(QVBoxLayout())
self.my_widget.layout().addWidget(self.pixmap_label)
self.my_widget.layout().addWidget(self.text_label)
if self.my_widget is None:
print("Cannot find image file.")
return
self.my_entity = naali.createEntity()
position = self.my_entity.GetOrCreateComponentRaw(
"EC_Placeable", "pos",
PythonQt.private.AttributeChange.Disconnected, False)
position.position = avatar_pos.position
self.ec_billboard = self.my_entity.GetOrCreateComponentRaw(
"EC_BillboardWidget", "test",
PythonQt.private.AttributeChange.Disconnected, False)
if self.ec_billboard is None:
print("Cannot create EC_Billboard component.")
return
self.ec_billboard.SetPosition(0, 0, 1)
self.ec_billboard.SetWidth(1)
self.ec_billboard.SetHeight(1)
self.ec_billboard.SetWidget(self.my_widget)
self.size_timer = QTimer()
self.size_timer.connect("timeout()", self.animateSize)
self.size_timer.start(100)
self.text_timer = QTimer()
self.text_timer.connect("timeout()", self.animateText)
self.text_timer.start(1000)
class nameSwitcher(ts3plugin):
name = "Name Switcher"
try: apiVersion = getCurrentApiVersion()
except: apiVersion = 21
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = ""
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0, "Toggle " + name, "")]
hotkeys = []
timer = QTimer()
interval = 1 * 1000 * 60
prefix = "Danny"
suffixes = path.join(getPluginPath(), "scripts", "nameSwitcher", "suffixes.txt")
last = ""
schid = 0
retcode = ""
def __init__(self):
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
with open(self.suffixes) as f:
self.suffixes = f.read().splitlines()
if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded.".format(timestamp(), self.name, self.author))
def stop(self):
if self.timer.isActive(): self.timer.stop()
def tick(self):
new = choice(self.suffixes)
while new == self.last: new = choice(self.suffixes)
ts3lib.setClientSelfVariableAsString(self.schid, ts3defines.ClientProperties.CLIENT_NICKNAME, self.prefix + new)
self.retcode = ts3lib.createReturnCode()
ts3lib.flushClientSelfUpdates(self.schid, self.retcode)
self.last = new
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL or menuItemID != 0: return
if self.timer.isActive(): self.timer.stop()
else:
self.schid = schid
self.timer.start(self.interval)
self.tick()
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
if self.timer.isActive(): self.timer.stop()
def onServerErrorEvent(self, schid, errorMessage, error, returnCode, extraMessage):
if returnCode != self.retcode: return
self.retcode = ""
if error == ts3defines.ERROR_client_nickname_inuse: self.tick()
return True
def onMenuItemEvent(self, serverConnectionHandlerID, atype, menuItemID,
selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 0:
timer = QTimer(self)
connect(
timer, SIGNAL(timeout()), this,
SLOT(
self.changeName(serverConnectionHandlerID,
names[self.i])))
timer.start(5000)
def toggleTimer(self, schid):
if self.timer is None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.timer.isActive():
self.timer.stop()
self.timer = None
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
self.schid = schid
err, self.clid = ts3lib.getClientID(schid)
self.timer.start(randint(30 * 1000, 120 * 1000))
ts3lib.printMessageToCurrentTab('Timer started!')
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if menuItemID == 0:
if self.timer == None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.timer.isActive():
self.timer.stop()
self.timer = None
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
self.timer.start(10)
ts3lib.printMessageToCurrentTab('Timer started!')
ts3lib.printMessageToCurrentTab("{0}Set {1} to [color=yellow]{2}[/color]".format(self.timestamp(),self.name,self.toggle))
def toggleTimer(self, schid):
if self.timer is None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.timer.isActive():
self.timer.stop()
self.timer = None
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
step = inputBox(self.name, 'Interval in Milliseconds:')
if step: interval = int(step)
else: interval = 1000
self.schid = schid
self.timer.start(interval)
ts3lib.printMessageToCurrentTab('Timer started!')
class penTest(ts3plugin):
name = "Pen Tester"
apiVersion = 21
requestAutoload = False
version = "1"
author = "Bluscream"
description = ""
offersConfigure = False
commandKeyword = "pt"
infoTitle = None
# path = "scripts/penTest"
menuItems = []
hotkeys = []
timer = QTimer()
cmd = ""
def __init__(self):
self.timer.timeout.connect(self.tick)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def processCommand(self, schid, cmd):
cmd = cmd.split(" ", 1)
amount = 1
try:
amount = int(cmd[0])
except:
pass
if amount > 10:
self.i = 1
self.schid = schid
self.c = amount + 1
self.cmd = cmd[1]
self.timer.start(1)
else:
for i in range(amount):
sendCommand(self.name, cmd[1], schid, True)
i += 1
return True
def tick(self):
if self.i >= self.c: self.timer.stop()
sendCommand(self.name, self.cmd, self.schid, True)
self.i += 1
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if menuItemID == 0:
if self.timer is None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.timer.isActive():
self.timer.stop()
self.timer = None
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME,
self.nick)
ts3lib.flushClientSelfUpdates(schid)
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
(err, self.nick) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
self.schid = schid
(err, self.clid) = ts3lib.getClientID(schid)
self.timer.start(1000)
ts3lib.printMessageToCurrentTab('Timer started!')
def __init__(self):
if path.isfile(self.ini):
self.config.read(self.ini)
else:
self.config["general"] = {
"cfgver": "1",
"debug": "False",
"nick": "TeamspeakUser",
"customNick": "False",
"interval": "1000",
"separator": " "
}
with open(self.ini, 'w') as configfile:
self.config.write(configfile)
# if self.timer is None:
self.timer = QTimer()
self.timer.timeout.connect(self.tick)
if self.debug:
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(self.timestamp(), self.name, self.author))
class complaintReminder(ts3plugin):
name = "Complaint Reminder"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 21
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Reminds you about due complaints."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = []
hotkeys = []
timer = QTimer()
servers = {}
waitingForList = []
interval = 60 * 1000
def __init__(self):
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
err, schids = ts3lib.getServerConnectionHandlerList()
for schid in schids:
err, status = ts3lib.getConnectionStatus(schid)
self.onConnectStatusChangeEvent(schid, status, err)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
if self.timer.isActive():
self.timer.stop()
def tick(self):
if PluginHost.cfg.getboolean("general", "verbose"): print(self.servers)
if len(self.servers) < 1:
self.timer.stop()
return
for schid in self.servers:
self.waitingForList.append(schid)
ts3lib.requestComplainList(schid, 0, self.__class__.__name__)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
self.servers.pop(schid, None)
if len(self.servers) < 1: self.timer.stop()
elif newStatus == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
self.waitingForList.append(schid)
ts3lib.requestComplainList(schid, 0, self.__class__.__name__)
def onComplainListEvent(self, schid, targetClientDatabaseID,
targetClientNickName, fromClientDatabaseID,
fromClientNickName, complainReason, timestamp):
if not schid in self.waitingForList and not schid in self.servers:
return
if not self.timer.isActive() and len(self.servers) == 1:
self.timer.start(self.interval)
if not schid in self.servers: self.servers[schid] = []
complaint = (targetClientDatabaseID, fromClientDatabaseID)
if not complaint in self.servers[schid]:
self.servers[schid].append(complaint)
(err, ownID) = ts3lib.getClientID(schid)
ts3lib.requestClientPoke(
schid, ownID, 'New complaint for "{}" by "{}"'.format(
targetClientNickName, fromClientNickName)
) # clientURL(schid, nickname=targetClientNickName), clientURL(schid, nickname=fromClientNickName)
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if returnCode != self.__class__.__name__: return False
if error == ts3defines.ERROR_database_empty_result:
if schid in self.servers:
if len(self.servers[schid]) > 0: self.servers[schid].clear()
else:
self.servers[schid] = []
if not self.timer.isActive() and len(self.servers) == 1:
self.timer.start(self.interval)
return True
elif error == ts3defines.ERROR_ok:
return True
return False
def onServerPermissionErrorEvent(self, schid, errorMessage, error,
returnCode, failedPermissionID):
if returnCode != self.__class__.__name__ or error != ts3defines.ERROR_permissions_client_insufficient or failedPermissionID != 207:
return False
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, ">", "not enough permissions on tab ", schid, "!")
if schid in self.waitingForList: self.waitingForList.remove(schid)
return True
class gommeHD(ts3plugin):
name = "GommeHD nifty tricks"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = ""
offersConfigure = False
commandKeyword = ""
infoTitle = None
hotkeys = []
menuItems = [
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1,
"Ask for avatar", "scripts/%s/ask_for_avatar.png" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0,
"Dynamic Silence", ""),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 0, "Send Steam",
"scripts/%s/steam.png" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 0, "Send Steam",
"scripts/%s/steam.png" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 1, "Toggle aka",
"")
]
suid = "QTRtPmYiSKpMS8Oyd4hyztcvLqU="
channelAdminGroupID = 10
premiumGroupIDs = ["31", "30", "14"]
ruheGroupID = "17"
gommeBotNick = "Gomme-Bot"
dynamicSilenceName = "msg me"
delay = 1500
nick_enabled = True
nicknames = [
"Qmx1c2NyZWFt=", # Bluscream
"Q2hyaXN0b3BoZXIgQXVyaWNo=", # Christopher Aurich
"RGFubnkgUmFkbWFjaGVy=", # Danny Radmacher
"aHR0cHM6Ly9yNHAzLm5ldA=", # https://r4p3.net
"player.getDisplayName()",
"ts3lib.getClientID(schid)",
"ts3lib.getClientDisplayName()",
"std::string tanga",
"bWlzcyBqZW5uaWZlcg=" # miss jennifer
]
settings = {"maxclients": 10, "tp": 23}
violations = defaultdict(int)
askForAvatar = False
dynamicSilence = True
alreadyAsked = []
schid = 0
clids = []
dynamicSilenceCache = []
gommeBotID = 0
timer = QTimer()
aka = (0, 0, "", "")
msg = "um nur Personen ab dem ausgewählen Rang die Möglichkeit zu geben, in deinen Channel zu joinen."
blockMSG = "Diesen Befehl kannst du nur als Channel-Admin ausführen!"
ignoreMSG = [
'Gomme-Bot geöffnet! Tippe "ruhe", um den Ruhe-Rang zu erhalten!',
'Du möchtest nicht mehr angeschrieben werden? Tippe "togglebot"',
"Bevor du alle Funktionalitäten nutzen kannst, musst du unseren Nutzungsbedingungen und der Datenschutzerklärung zustimmen. Diese findest du auf https://gommehd.net/terms/teamspeak/de/",
'Dies kannst du jedoch mit "abort" rückgängig machen.',
'Viel Spaß auf dem Teamspeak!'
]
agreeMSG = 'Schreibe "agree" in den Chat, um deine Zustimmung zu erteilen.'
steammsg = """
Steam: [url]https://steamcommunity.com/profiles/76561198022446661[/url]
Add as friend: [url]steam://friends/add/76561198022446661[/url]
Common games: [url]https://steamcommunity.com/profiles/76561198022446661/games/?tab=all&games_in_common=1[/url]
Account Value: [url]https://steamdb.info/calculator/76561198022446661/?cc=eu[/url]
Trade URL: [url]https://steamcommunity.com/tradeoffer/new/?partner=62180933&token=fSMYHMGM[/url]
Live Broadcast: [url]https://steamcommunity.com/broadcast/watch/76561198022446661[/url]
"""
avatarmsg = """Hey {nick}, es wäre voll knorke von dir wenn du mir erlauben würdest dein Premium zu benutzen damit ich mir nen avatar setzen kann.
Dabei gehst du keine scam Gefahr ein weil du mir das jederzeit wieder wegnehmen kannst auch wenn ich schon disconnected bin (frag jeden das ist so)
Ich erklär dir auch wie's geht:
1. Geh auf den Gomme minecraft server und gib [color=red]/ts set {myuid}[/color] ein und schreib mir in TS deinen minecraft namen.
2. Ich werde deinen mc namen dem gomme bot schreiben damit er mir premium geben kann
3. Wenn ich dann Premium habe werde ich mir kurz nen avatar setzen max. 2 min
4. Dann sag ich dir bescheid und du gibst in minecraft [color=green]/ts set {uid}[/color] ein und hast dein premium wieder
5. Ich werde mich bei dir bedanken ;)
"""
def __init__(self):
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def menuCreated(self):
self.checkMenus()
def currentServerConnectionChanged(self, schid):
self.checkMenus(schid)
def checkMenus(self, schid=0):
if not self.name in PluginHost.active: return
if schid < 1: schid = ts3lib.getCurrentServerConnectionHandlerID()
err, status = ts3lib.getConnectionStatus(schid)
if status != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: self.toggleMenus(False)
else: self.toggleMenus(True)
def toggleMenus(self, enabled):
for menuItem in self.menuItems:
try:
ts3lib.setPluginMenuEnabled(
PluginHost.globalMenuID(self, menuItem[1]), enabled)
except:
pass
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginItemType.PLUGIN_SERVER:
if menuItemID == 0:
self.dynamicSilence = not self.dynamicSilence
ts3lib.printMessageToCurrentTab(
"{}{}: DynamicSilence set to [color=orange]{}".format(
timestamp(), self.name, self.dynamicSilence))
elif menuItemID == 1:
self.askForAvatar = not self.askForAvatar
ts3lib.printMessageToCurrentTab(
"{}askForAvatar set to [color=orange]{}".format(
timestamp(), self.askForAvatar))
if not self.askForAvatar:
self.clids = []
self.timer.stop()
return
(err, clids) = ts3lib.getClientList(schid)
for c in clids:
ts3lib.requestClientVariables(schid, c)
for c in clids:
(err, uid) = ts3lib.getClientVariable(
schid, c,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if getContactStatus(uid) == ContactStatus.BLOCKED: continue
if uid in self.alreadyAsked: continue
(err, sgroups) = ts3lib.getClientVariableAsString(
schid, c,
ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
sgroups = sgroups.split(",")
if self.ruheGroupID in sgroups: continue
if set(sgroups).isdisjoint(self.premiumGroupIDs): continue
self.clids.append(c)
ts3lib.printMessageToCurrentTab(
"{}Asking {} clients for avatar".format(
timestamp(), len(self.clids)))
self.schid = schid
self.timer.start(1000)
if atype == ts3defines.PluginItemType.PLUGIN_CHANNEL:
ts3lib.requestSendChannelTextMsg(schid, self.steammsg,
selectedItemID)
elif atype == ts3defines.PluginItemType.PLUGIN_CLIENT:
if menuItemID == 0:
ts3lib.requestSendPrivateTextMsg(schid, self.steammsg,
selectedItemID)
elif menuItemID == 1:
print(self.aka)
if self.aka != (0, 0, "", ""):
self.aka = (0, 0, "", "")
return
realname = inputBox(self.name, "Real name:")
if not realname: return
(err, name) = ts3lib.getClientVariable(
schid, selectedItemID,
ts3defines.ClientProperties.CLIENT_NICKNAME)
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME,
"{} aka {}".format(realname, name))
ts3lib.flushClientSelfUpdates(schid)
self.aka = (schid, selectedItemID, realname, name)
def tick(self):
if not self.askForAvatar or not self.schid or len(self.clids) < 1:
self.timer.stop()
return
(err, myuid) = ts3lib.getClientSelfVariable(
self.schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
(err, uid) = ts3lib.getClientVariable(
self.schid, self.clids[0],
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
(err, nick) = ts3lib.getClientVariable(
self.schid, self.clids[0],
ts3defines.ClientProperties.CLIENT_NICKNAME)
ts3lib.requestSendPrivateTextMsg(
self.schid,
self.avatarmsg.replace("{nick}",
nick).replace("{myuid}",
myuid).replace("{uid}", uid),
self.clids[0])
self.alreadyAsked.append(uid)
del self.clids[0]
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName,
fromUniqueIdentifier, message, ffIgnored):
if fromUniqueIdentifier != "serveradmin": return
if fromName != self.gommeBotNick: return
print(message, self.agreeMSG, message == self.agreeMSG)
self.schid = schid
self.gommeBotID = fromID
if message.endswith(self.msg):
QTimer.singleShot(self.delay, self.sendMessage)
elif message == self.blockMSG:
QTimer.singleShot(self.delay, self.sendMessage)
elif message == self.agreeMSG:
ts3lib.requestSendPrivateTextMsg(self.schid, "agree",
self.gommeBotID)
return True
elif message in self.ignoreMSG:
return True
def sendMessage(self):
ts3lib.requestSendPrivateTextMsg(self.schid, "registriert",
self.gommeBotID)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if not self.askForAvatar: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
if oldChannelID != 0: return
(err, uid) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if getContactStatus(uid) == ContactStatus.BLOCKED: return
if uid in self.alreadyAsked: return
(err, sgroups) = ts3lib.getClientVariableAsString(
schid, clientID,
ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
sgroups = sgroups.split(",")
if self.ruheGroupID in sgroups: return
if set(sgroups).isdisjoint(self.premiumGroupIDs): return
(err, myuid) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
(err, nick) = ts3lib.getClientVariable(
schid, clientID, ts3defines.ClientProperties.CLIENT_NICKNAME)
ts3lib.requestSendPrivateTextMsg(
schid,
self.avatarmsg.replace("{nick}",
nick).replace("{myuid}",
myuid).replace("{uid}", uid),
clientID)
self.alreadyAsked.append(uid)
def onClientChannelGroupChangedEvent(self, schid, channelGroupID,
channelID, clientID, invokerClientID,
invokerName, invokerUniqueIdentity):
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID: return
if channelGroupID != self.channelAdminGroupID: return
if invokerClientID == 0:
(err, ntp) = ts3lib.getChannelVariable(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
if not ntp or ntp == 0:
ts3lib.setChannelVariableAsInt(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER,
self.settings["tp"])
ts3lib.setChannelVariableAsInt(
schid, channelID, ts3defines.ChannelPropertiesRare.
CHANNEL_FLAG_MAXCLIENTS_UNLIMITED, 0)
ts3lib.setChannelVariableAsInt(
schid, channelID,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS,
self.settings["maxclients"])
(err, cnp) = ts3lib.getChannelVariable(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC)
if not cnp or cnp == "":
ts3lib.setChannelVariableAsString(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NAME_PHONETIC,
"Team | Lounge 1")
ts3lib.flushChannelUpdates(schid, channelID)
if self.gommeBotID < 1: return
ts3lib.requestSendPrivateTextMsg(schid, "registriert", self.gommeBotID)
def onUpdateChannelEditedEvent(self, schid, channelID, invokerID,
invokerName, invokerUniqueIdentifier):
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, ownID) = ts3lib.getClientID(schid)
if invokerID == ownID:
(err, self.settings["maxclients"]) = ts3lib.getChannelVariable(
schid, channelID,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
(err, self.settings["tp"]) = ts3lib.getChannelVariable(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
(err, ownChannel) = ts3lib.getChannelOfClient(schid, ownID)
if channelID != ownChannel: return
(err, invokerChannel) = ts3lib.getChannelOfClient(schid, invokerID)
if invokerChannel == channelID: return
_needed = False
(err, ntp) = ts3lib.getChannelVariable(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER)
if ntp != self.settings["tp"]:
_needed = True
ts3lib.setChannelVariableAsInt(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_NEEDED_TALK_POWER,
self.settings["tp"])
(err, cmc) = ts3lib.getChannelVariable(
schid, channelID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
ts3lib.setChannelVariableAsInt(
schid, channelID,
ts3defines.ChannelPropertiesRare.CHANNEL_FLAG_MAXCLIENTS_UNLIMITED,
0)
if cmc != self.settings["maxclients"]:
_needed = True
ts3lib.setChannelVariableAsInt(
schid, channelID,
ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS,
self.settings["maxclients"])
if _needed:
ts3lib.flushChannelUpdates(schid, channelID)
self.violations[invokerUniqueIdentifier] += 1
if self.violations[invokerUniqueIdentifier] > 2:
(err, dbid) = ts3lib.getClientVariable(
schid, ts3defines.ClientPropertiesRare.CLIENT_DATABASE_ID)
ts3lib.requestSetClientChannelGroup(schid, [9], [channelID],
[dbid])
del self.violations[invokerUniqueIdentifier]
def onUpdateClientEvent(self, schid, clid, invokerID, invokerName,
invokerUniqueIdentifier):
if schid != self.aka[0]: return
if clid != self.aka[1]: return
(err, name) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_NICKNAME)
if name == self.aka[3]: return
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME,
"{} aka {}".format(self.aka[2], name))
ts3lib.flushClientSelfUpdates(schid)
def onIncomingClientQueryEvent(self, schid, commandText):
if not self.dynamicSilence: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
if commandText.split(" ", 1)[0] != "notifyclientupdated": return
cmd, params = parseCommand(commandText)
if len(params) > 0 and "client_nickname" in params:
clid = int(params["clid"])
# (err, ownID) = ts3lib.getClientID(schid)
# if clid == ownID: return
(err, uid) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if getContactStatus(uid) != ContactStatus.FRIEND: return
if not self.dynamicSilenceName in params["client_nickname"].lower(
):
return
ts3lib.requestSendPrivateTextMsg(
schid, "Yes, {}-{}?".format(clientURL(schid, clid),
choice(["chan", "san"])), clid)
# ts3lib.printMessageToCurrentTab("{} {}".format(cmd, params)) # ["client_nickname"][1]
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus != ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
return
if not self.nick_enabled: return
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if suid != self.suid: return
(err, name) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
_name = choice(self.nicknames)
if _name == name: return
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME, _name)
ts3lib.flushClientSelfUpdates(schid)
class dontHide(ts3plugin):
name = "Don't Hide"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Shows clients that hide."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = []
hotkeys = []
timer = QTimer()
ts3host = None
def __init__(self):
if "aaa_ts3Ext" in PluginHost.active:
ts3ext = PluginHost.active["aaa_ts3Ext"]
self.ts3host = ts3ext.ts3host
del self.timer
else:
retry = 1000
self.timer.singleShot(retry, self.__init__)
ts3lib.printMessageToCurrentTab(
"{}: [color=red]Dependency not yet loaded, retrying in {} second(s)!"
.format(self.name, retry / 1000))
return
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
if hasattr(self, "timer"):
if self.timer.isActive(): self.timer.stop()
del self.timer
def onClientMoveEvent(self, schid, clid, oldChannelID, newChannelID,
visibility, moveMessage):
if not newChannelID: return
if visibility == ts3defines.Visibility.LEAVE_VISIBILITY:
cmd = "notifycliententerview"
client = self.buildClient(schid, clid, oldChannelID, newChannelID)
for k in client:
if client[k] != "":
cmd += " {}={}".format(k, client[k])
else:
cmd += " {}".format(k)
sendCommand(self.name, cmd, schid, False, True)
def buildClient(self, schid, clid, oldChannelID, newChannelID):
_client = self.ts3host.getUser(schid, clid)
client = dict()
client["reasonid"] = "0"
client["cfid"] = oldChannelID
client["ctid"] = newChannelID
client["client_channel_group_id"] = _client.getChannelGroupId()
(err,
client["client_servergroups"]) = ts3lib.getClientVariableAsString(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_SERVERGROUPS)
(err, client["client_channel_group_inherited_channel_id"]
) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.
CLIENT_CHANNEL_GROUP_INHERITED_CHANNEL_ID)
client["client_input_muted"] = _client.isInputMuted
client["client_output_muted"] = _client.isOutputMuted
client["client_outputonly_muted"] = _client.isOutputOnlyMuted
(err, client["client_input_hardware"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_INPUT_HARDWARE)
(err, client["client_output_hardware"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_OUTPUT_HARDWARE)
client["client_is_recording"] = _client.isRecording
(err, client["client_type"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
client["client_is_talker"] = _client.isTalker
client["client_away"] = _client.isAway
client["client_is_channel_commander"] = _client.isChannelCommander
(err, client["client_is_priority_speaker"]) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_IS_PRIORITY_SPEAKER)
client["clid"] = clid
client["client_database_id"] = _client.databaseID
client["client_talk_power"] = _client.talkPower
(err, client["client_unread_messages"]) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_UNREAD_MESSAGES)
(err, client["client_needed_serverquery_view_power"]
) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.
CLIENT_NEEDED_SERVERQUERY_VIEW_POWER)
client["client_icon_id"] = _client.iconID
client["client_unique_identifier"] = _client.uniqueIdentifier
client["client_nickname"] = _client.name
(err, client["client_meta_data"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_META_DATA)
(err, client["client_away_message"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_AWAY_MESSAGE)
(err, client["client_flag_avatar"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_FLAG_AVATAR)
(err, client["client_talk_request"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientProperties.CLIENT_OUTPUT_HARDWARE)
(err, client["client_talk_request_msg"]) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_TALK_REQUEST_MSG)
client["client_description"] = _client.description
(err, client["client_nickname_phonetic"]) = ts3lib.getClientVariable(
schid, clid,
ts3defines.ClientPropertiesRare.CLIENT_NICKNAME_PHONETIC)
(err, client["client_country"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_COUNTRY)
(err, client["client_badges"]) = ts3lib.getClientVariable(
schid, clid, ts3defines.ClientPropertiesRare.CLIENT_BADGES)
return client
def startTimer(self, schid):
self.timers[schid] = QTimer()
self.timers[schid].timeout.connect(self.tick)
self.timers[schid].start(1000)
class passwordCracker(ts3plugin):
name = "PW Cracker"
apiVersion = 22
requestAutoload = True
version = "1.0"
author = "Bluscream"
description = "<insert lenny face here>"
offersConfigure = False
commandKeyword = ""
infoTitle = "[b]Cracking Password...[/b]"
menuItems = [
(PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0, "== {0} ==".format(name),
""), (PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1, "Stop Cracker", ""),
(PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 2, "Add PW to cracker", ""),
(PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 10, "== {0} ==".format(name),
""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 11, "== {0} ==".format(name),
""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 1, "Crack PW (Dictionary)",
""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 2, "Crack PW (Bruteforce)",
""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 3, "Add PW to cracker", ""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 4, "Try Password", ""),
(PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL, 12, "== {0} ==".format(name),
"")
]
hotkeys = []
debug = False
pwpath = os.path.join(pytson.getPluginPath(), "scripts", __name__,
"pws.txt")
schid = 0
cid = 0
pws = []
pwc = 0
cracking = False
flooding = False
timer = QTimer()
interval = 300
antiflood_delay = 2500
step = 1
retcode = ""
mode = 0
dlg = None
status = ""
requested = False
def __init__(self):
content = []
with open(self.pwpath, encoding="utf8") as f:
content = f.readlines()
self.pws = [x.strip() for x in content]
self.timer.timeout.connect(self.tick)
ts3lib.requestServerVariables(
ts3lib.getCurrentServerConnectionHandlerID())
if self.debug:
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
self.timer.stop()
self.timer = None
del self.timer
self.timer = QTimer()
def menuCreated(self):
if not self.name in PluginHost.active: return
for id in [0, 10, 11, 12]:
ts3lib.setPluginMenuEnabled(PluginHost.globalMenuID(self, id),
False)
def startTimer(self, schid=0, cid=0):
if schid != 0: self.schid = schid
if cid != 0: self.cid = cid
self.timer.start(self.interval)
self.tick()
ts3lib.requestInfoUpdate(self.schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == PluginMenuType.PLUGIN_MENU_TYPE_CHANNEL:
if menuItemID == 0:
if not self.dlg: self.dlg = StatusDialog(self)
self.dlg.show()
self.dlg.raise_()
self.dlg.activateWindow()
elif menuItemID == 1:
(err, haspw) = ts3lib.getChannelVariable(
schid, selectedItemID,
ChannelProperties.CHANNEL_FLAG_PASSWORD)
if not haspw:
(err, name) = ts3lib.getChannelVariable(
schid, selectedItemID, ChannelProperties.CHANNEL_NAME)
msgBox(
"Channel \"{0}\" has no password to crack!".format(
name), QMessageBox.Warning)
return
self.mode = 0
self.step = 1
self.pwc = 0
self.startTimer(schid, selectedItemID)
elif menuItemID == 2:
(err, haspw) = ts3lib.getChannelVariable(
schid, selectedItemID,
ChannelProperties.CHANNEL_FLAG_PASSWORD)
if not haspw:
(err, name) = ts3lib.getChannelVariable(
schid, selectedItemID, ChannelProperties.CHANNEL_NAME)
msgBox(
"Channel \"{0}\" has no password to crack!".format(
name), QMessageBox.Warning)
return
self.mode = 1
step = inputBox(self.name, 'How much to increase per try?')
if step: self.step = int(step)
start = inputBox(self.name, 'Where to start?')
if start: self.pwc = int(start)
self.startTimer(schid, selectedItemID)
elif menuItemID == 3:
(err, path,
pw) = ts3lib.getChannelConnectInfo(schid, selectedItemID)
if pw == None or pw == False or pw == "":
(err, name) = ts3lib.getChannelVariable(
schid, selectedItemID, ChannelProperties.CHANNEL_NAME)
msgBox('No password saved for channel {0}'.format(name))
return
elif pw in self.pws:
msgBox(
"Not adding \"{0}\" to password db\n\nIt already exists!"
.format(pw), QMessageBox.Warning)
return
self.pws.append(pw)
with open(self.pwpath, "a") as myfile:
myfile.write('\n{0}'.format(pw))
msgBox("Added \"{0}\" to password db".format(pw))
elif menuItemID == 4:
(err, name) = ts3lib.getChannelVariable(
schid, selectedItemID, ChannelProperties.CHANNEL_NAME)
pw = inputBox("{0} - {1}".format(self.name, name), "Password:"******"passwordCracker:manual")
elif atype == PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 1:
self.timer.stop()
ts3lib.printMessageToCurrentTab('Timer stopped!')
elif menuItemID == 2:
pw = inputBox("Enter Channel Password to add", "Password:"******"":
msgBox("Not adding \"{0}\" to password db".format(pw),
QMessageBox.Warning)
return
elif pw in self.pws:
msgBox(
"Not adding \"{0}\" to password db\n\nIt already exists!"
.format(pw), QMessageBox.Warning)
return
self.pws.append(pw)
with open(self.pwpath, "a") as myfile:
myfile.write('\n{0}'.format(pw))
msgBox("Added \"{0}\" to password db".format(pw))
def infoData(self, schid, id, atype):
if not atype == PluginItemType.PLUGIN_CHANNEL: return None
if not self.cid == id: return None
if not self.schid == schid: return None
if self.mode == 0:
msg = "Trying: {0} / {1}\nCurrent: {2}\nStatus: {3}".format(
self.pwc + 1,
len(self.pws) + 1, self.pws[self.pwc], self.status)
elif self.mode == 1:
msg = "Trying: {0}\nStatus: {1}".format(self.pwc, self.status)
return [msg]
def tick(self):
try:
self.retcode = ts3lib.createReturnCode()
if self.mode == 0:
if self.pwc >= len(self.pws):
self.timer.stop()
(err, name) = ts3lib.getChannelVariable(
self.schid, self.cid, ChannelProperties.CHANNEL_NAME)
msgBox(
"Password for channel \"{0}\" was not found :(\n\nTried {1} passwords."
.format(name, self.pwc + 1))
self.cracking = False
return
pw = self.pws[self.pwc]
elif self.mode == 1:
pw = str(self.pwc)
err = ts3lib.verifyChannelPassword(self.schid, self.cid, pw,
self.retcode)
if err != ERROR_ok:
(er, status) = ts3lib.getErrorMessage(err)
print(
'ERROR {0} ({1}) while trying password \"{2}\" for channel #{3} on server #{4}'
.format(status, err, pw, self.cid, self.schid))
# else: print('[{0}] Trying password \"{1}\" for channel #{2} on server #{3}'.format(self.pwc, pw, self.cid, self.schid))
if not self.flooding: self.pwc += self.step
except:
from traceback import format_exc
ts3lib.logMessage(format_exc(), LogLevel.LogLevel_ERROR, "pyTSon",
0)
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if returnCode == "passwordCracker:manual":
(err,
name) = ts3lib.getChannelVariable(schid, self.cid,
ChannelProperties.CHANNEL_NAME)
errorMessage = errorMessage.title()
msgBox("Channel: {0}\n\nPW: {1}\n\nResult: {2}".format(
name, self.pw, errorMessage))
if not returnCode == self.retcode: return
errorMessage = errorMessage.title()
if error == ERROR_channel_invalid_password:
if self.flooding: self.flooding = False
self.status = '[color=orange]{0}[/color]'.format(errorMessage)
ts3lib.requestInfoUpdate(schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
elif error == ERROR_client_is_flooding:
self.flooding = True
self.timer.stop()
QTimer.singleShot(self.antiflood_delay, self.startTimer)
self.status = '[color=red]{0}[/color]'.format(errorMessage)
ts3lib.requestInfoUpdate(schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
elif error == ERROR_channel_invalid_id:
self.timer.stop()
self.status = '[color=red]{0}[/color]'.format(errorMessage)
ts3lib.requestInfoUpdate(schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
msgBox(
"Channel #{0} is invalid!\n\nStopping Cracker!".format(
self.cid), QMessageBox.Warning)
elif error == ERROR_ok:
if self.flooding: self.flooding = False
self.timer.stop()
(err,
name) = ts3lib.getChannelVariable(schid, self.cid,
ChannelProperties.CHANNEL_NAME)
ts3lib.printMessageToCurrentTab(
'Channel: {0} Password: \"{1}\"'.format(
channelURL(schid, self.cid, name),
self.pws[self.pwc -
1] if self.mode == 0 else self.pwc - 1))
self.status = '[color=green]{0}[/color]'.format(errorMessage)
ts3lib.requestInfoUpdate(schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
if confirm(
"Password found! ({0} / {1})".format(
self.pwc, len(self.pws))
if self.mode == 0 else "Password found!",
"Password \"{0}\" was found for channel \"{1}\"\n\nDo you want to join now?"
.format(
self.pws[self.pwc -
1] if self.mode == 0 else self.pwc - 1,
name)):
(err, ownID) = ts3lib.getClientID(schid)
ts3lib.requestClientMove(
schid, ownID, self.cid,
self.pws[self.pwc -
1] if self.mode == 0 else str(self.pwc - 1))
else:
self.status = errorMessage
ts3lib.requestInfoUpdate(schid, PluginItemType.PLUGIN_CHANNEL,
self.cid)
if error in [ERROR_channel_invalid_id, ERROR_ok
] or returnCode in ["passwordCracker:manual"]:
self.cracking = False
return True
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
pass
def onUpdateChannelEditedEvent(self, schid, channelID, invokerID,
invokerName, invokerUniqueIdentifier):
if not self.cracking: return
if not self.cid == channelID: return
if not self.schid == schid: return
(err, haspw) = ts3lib.getChannelVariable(
schid, channelID, ChannelProperties.CHANNEL_FLAG_PASSWORD)
if haspw: return
self.timer.stop()
(err, name) = ts3lib.getChannelVariable(schid, channelID,
ChannelProperties.CHANNEL_NAME)
if confirm(
"Password removed",
"Password was removed from channel \"{0}\" by \"{1}\"\n\nDo you want to join now?"
.format(name, invokerName)):
(err, ownID) = ts3lib.getClientID(self.schid)
ts3lib.requestClientMove(schid, ownID, channelID, "")
self.cracking = False
def onDelChannelEvent(self, schid, channelID, invokerID, invokerName,
invokerUniqueIdentifier):
if not self.cracking: return
if not self.cid == channelID: return
if not self.schid == schid: return
self.timer.stop()
msgBox(
"Channel #{0} got deleted by \"{1}\"\n\nStopping Cracker!".format(
self.cid, invokerName), QMessageBox.Warning)
self.cracking = False
def onServerUpdatedEvent(self, schid):
if not self.requested: return
self.requested = False
self.interval = calculateInterval(
schid, AntiFloodPoints.VERIFYCHANNELPASSWORD, self.name)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
self.requested = True
ts3lib.requestServerVariables(schid)
if newStatus == ConnectStatus.STATUS_DISCONNECTED:
if not self.cracking: return
if not self.schid == schid: return
self.timer.stop()
# (err, name) = ts3lib.getChannelVariable(schid, self.cid, ChannelProperties.CHANNEL_NAME)
msgBox("Server left\n\nStopping Cracker!", QMessageBox.Warning)
self.cracking = False
class antiServerKick(ts3plugin):
name = "Anti Server Kick"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Auto rejoin servers after you got kicked."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = []
hotkeys = []
debug = False
whitelistUIDs = ["serveradmin"]
delay = 2500
timer = QTimer()
tabs = {}
schid = 0
def __init__(self):
if "aaa_ts3Ext" in PluginHost.active:
self.tabs = PluginHost.active["aaa_ts3Ext"].tabs
ts3lib.logMessage("{}: Dependency loaded".format(self.name),
ts3defines.LogLevel.LogLevel_WARNING, "pyTSon",
0)
else:
retry = 1000
self.timer.singleShot(retry, self.__init__)
# ts3lib.logMessage("{}: Dependency not yet loaded, retrying in {} second(s)!".format(self.name, retry/1000), ts3defines.LogLevel.LogLevel_WARNING, "pyTSon", 0)
return
log(
self, LogLevel.LogLevel_DEBUG,
"[color=orange]{0}[/color] Plugin for pyTSon by [url=https://github.com/{1}]{1}[/url] loaded."
.format(self.name, self.author), 0)
def onClientKickFromServerEvent(self, schid, clientID, oldChannelID,
newChannelID, visibility, kickerID,
kickerName, kickerUniqueIdentifier,
kickMessage):
if kickerID == clientID: return
if schid not in self.tabs: return
if clientID != self.tabs[schid]["clid"]: return
if kickerUniqueIdentifier in self.whitelistUIDs: return
if self.delay > 0:
self.schid = schid
QTimer.singleShot(self.delay, self.reconnect)
else:
self.reconnect(schid)
def reconnect(self, schid=None):
try:
schid = schid if schid else self.schid
args = [
ts3defines.PluginConnectTab.
PLUGIN_CONNECT_TAB_NEW_IF_CURRENT_CONNECTED, # connectTab: int,
self.tabs[schid]["name"], # serverLabel: Union[str, unicode],
self.tabs[schid]
["address"], # serverAddress: Union[str, unicode],
self.tabs[schid]["pw"], # serverPassword: Union[str, unicode],
self.tabs[schid]["nick"], # nickname: Union[str, unicode],
self.tabs[schid]["cpath"], # channel: Union[str, unicode],
self.tabs[schid]
["cpw"], # channelPassword: Union[str, unicode]
"", # captureProfile: Union[str, unicode],
"", # playbackProfile: Union[str, unicode]
"", # hotkeyProfile: Union[str, unicode],
"Default Sound Pack (Female)", # soundPack
self.tabs[schid]["uid"], # userIdentity: Union[str, unicode],
self.tabs[schid]["token"], # oneTimeKey: Union[str, unicode],
self.tabs[schid][
"nick_phonetic"] # phoneticName: Union[str, unicode]
]
print("ts3lib.guiConnect({})".format("\", \"".join(
str(x) for x in args)))
ts3lib.guiConnect(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args[9],
args[10], args[11], args[12], args[13])
self.schid = 0
except:
from traceback import format_exc
ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR,
"pyTSon", 0)
class showQueries(ts3plugin):
name = "Query Viewer"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Shows you queries in channels.\n\nHomepage: https://github.com/Bluscream/Extended-Info-Plugin\n\n\nCheck out https://r4p3.net/forums/plugins.68/ for more plugins."
offersConfigure = False
commandKeyword = "query"
infoTitle = "[b]Queries:[/b]"
menuItems = []
hotkeys = []
debug = False
timer = QTimer()
cleartimer = QTimer()
schid = 0
queries = []
hqueries = []
hqueries_cache = []
query_uids = ["serveradmin", "ServerQuery"]
waitingFor = ""
retcode = ""
def __init__(self):
self.cleartimer.timeout.connect(self.clearQueries)
self.cleartimer.start(1000*18000)
if self.debug: ts3lib.printMessageToCurrentTab("[{0} {1}] [color=orange]{2}[/color] Plugin for pyTSon by [url=https://github.com/{3}]{4}[/url] loaded.".format(date(), Time(), self.name, self.author))
def stop(self):
self.timer.stop()
self.timer = None
del self.timer
self.timer = QTimer()
def onConnectStatusChangeEvent(self, schid, status, errorNumber):
if status == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
self.schid = schid
self.timer.timeout.connect(self.checkQueries)
self.timer.start(1000)
ts3lib.printMessageToCurrentTab('Timer started!')
elif status == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
if self.timer.isActive():
self.timer.stop()
self.schid = 0
ts3lib.printMessageToCurrentTab('Timer stopped!')
def checkQueries(self):
(err, clist) = ts3lib.getClientList(self.schid)
for c in clist:
if c in self.queries:
continue
else:
(err, ctype) = ts3lib.getClientVariable(self.schid, c, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if ctype != ts3defines.ClientType.ClientType_SERVERQUERY: continue
self.queries.append(c)
(err, cid) = ts3lib.getChannelOfClient(self.schid, c)
# (err, channelname) = ts3lib.getChannelVariable(self.schid, cid, ts3defines.ChannelProperties.CHANNEL_NAME)
ts3lib.printMessage(self.schid, "<{0}> Found Query {1} in channel {2}".format(Time(), clientURL(self.schid, c), channelURL(self.schid, cid)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
# self.waitingFor = self.query_uids[0]
# self.retcode = ts3lib.createReturnCode()
# ts3lib.requestClientIDs(self.schid, self.query_uids[0], self.retcode)
def clearQueries(self):
self.queries = []
ts3lib.printMessage(self.schid, "<{0}> Cleared Query List".format(Time()), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
def infoData(self, schid, id, atype):
try:
if atype == ts3defines.PluginItemType.PLUGIN_CHANNEL:
(error, clist) = ts3lib.getChannelClientList(schid, id)
i = []
for c in clist:
(error, clienttype) = ts3lib.getClientVariable(schid, c, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if clienttype == ts3defines.ClientType.ClientType_SERVERQUERY:
i.append(clientURL(schid, c))
if len(i) < 1: return
else: return i
except: return
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID, visibility, moveMessage):
# if oldChannelID != 0: return
(err, clienttype) = ts3lib.getClientVariable(schid, clientID, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if clienttype != ts3defines.ClientType.ClientType_SERVERQUERY: return
# (err, channelname) = ts3lib.getChannelVariable(schid, newChannelID, ts3defines.ChannelProperties.CHANNEL_NAME)
if visibility == ts3defines.Visibility.ENTER_VISIBILITY:
ts3lib.printMessage(schid, "<{0}> {1} enters view to channel {2}".format(Time(), clientURL(schid, clientID), channelURL(schid, newChannelID)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
elif visibility == ts3defines.Visibility.LEAVE_VISIBILITY:
ts3lib.printMessage(schid, "<{0}> {1} leaves from channel {2}{3}".format(Time(), clientURL(schid, clientID), channelURL(schid, oldChannelID), " ({})".format(moveMessage) if moveMessage else ""), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
else: ts3lib.printMessage(schid, "<{0}> {1} switched from channel {2} to {3}".format(Time(), clientURL(schid, clientID), channelURL(schid, oldChannelID), channelURL(schid, newChannelID)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
# <16:11:43> "charlie sheen" switched from channel "Intros Gratis <3" to "Serverteam-Gesucht Builder"
def onClientIDsEvent(self, schid, uid, clid, nickname):
# print('{0} == {1}: {2}'.format(uid, self.waitingFor, uid == self.waitingFor))
if not uid == self.waitingFor: return
(err, chan) = ts3lib.getChannelOfClient(schid, clid)
if err != ts3defines.ERROR_ok: self.hqueries.append((clid, uid, nickname))
def onClientIDsFinishedEvent(self, schid):
if not self.waitingFor in self.query_uids: return
if len(self.hqueries) > 0:
# qstring = ", ".join("[url=client://{0}/{1}]{2}[/url]".format(tup) for tup in self.queries)
qlist = ["[url=client://{}/{}]{}[/url]".format(*tup) for tup in self.hqueries]
qstring = ", ".join(qlist)
ts3lib.printMessage(schid, "<{0}> Found {1} hidden Queries with UID \"{2}\": {3}".format(Time(), len(self.hqueries), self.waitingFor, qstring), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
self.hqueries = []
if self.waitingFor == self.query_uids[0]:
self.waitingFor = self.query_uids[-1]
ts3lib.requestClientIDs(schid, self.query_uids[-1], self.retcode)
if self.waitingFor == self.query_uids[-1]:
self.waitingFor = False
def onServerErrorEvent(self, schid, errorMessage, error, returnCode, extraMessage):
if returnCode == self.retcode: return True
def printQueries(self):
(err, schids) = ts3lib.getServerConnectionHandlerList()
for schid in schids:
(err, cids) = ts3lib.getChannelList(schid)
for cid in cids:
(err, clids) = ts3lib.getChannelClientList(schid, cid)
msg = []
for clid in clids:
(err, ctype) = ts3lib.getClientVariable(schid, clid, ts3defines.ClientPropertiesRare.CLIENT_TYPE)
if ctype != ts3defines.ClientType.ClientType_SERVERQUERY: continue
msg.append(clientURL(schid, clid))
if len(msg) < 1: continue
ts3lib.printMessage(schid, "<{0}> {1} has [b]{2}[/b] Query Clients: {3}".format(Time(), channelURL(schid, cid), len(msg), ", ".join(msg)), ts3defines.PluginMessageTarget.PLUGIN_MESSAGE_TARGET_SERVER)
self.waitingFor = self.query_uids[0]
self.retcode = ts3lib.createReturnCode()
ts3lib.requestClientIDs(schid, self.query_uids[0], self.retcode)
def processCommand(self, schid, cmd):
cmd = cmd.split(' ', 1)
command = cmd[0].lower()
if command == "list":
self.printQueries()
return 1
class autoCommander(ts3plugin):
name = "Auto Channel Commander"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Automatically enable channel commander when switching channels.\n\nCheck out https://r4p3.net/forums/plugins.68/ for more plugins."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = [
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0, "Toggle %s"%name, "scripts/%s/commander_off.svg"%__name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1, "Toggle Channel Commander Spam", "scripts/%s/commander.svg"%__name__)
]
hotkeys = []
timer = QTimer()
schid = 0
requested = 0
retcode = __name__
enabled = False
def __init__(self):
self.timer.timeout.connect(self.tick)
if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded.".format(timestamp(),self.name,self.author))
def stop(self):
if self.timer.isActive(): self.timer.stop()
del self.timer
def toggleTimer(self, schid):
if self.timer.isActive():
self.timer.stop()
else:
interval = inputInt(self.name, 'Interval in Milliseconds:')
self.schid = schid
if interval < 1:
self.requested = schid
ts3lib.requestServerVariables(schid)
else: self.timer.start(interval)
def onServerUpdatedEvent(self, schid):
if not self.enabled: return
if self.requested != schid: return
self.requested = 0
self.schid = schid
self.timer.start(calculateInterval(schid, AntiFloodPoints.CLIENTUPDATE, self.name))
def tick(self):
(err, commander) =ts3lib.getClientSelfVariable(self.schid, ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER)
ts3lib.setClientSelfVariableAsInt(self.schid, ts3lib.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER, not commander)
ts3lib.flushClientSelfUpdates(self.schid, self.retcode)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if menuItemID == 0: self.enabled = not self.enabled
elif menuItemID == 1: self.toggleTimer(schid)
def onClientChannelGroupChangedEvent(self, schid, channelGroupID, channelID, clientID, invokerClientID, invokerName, invokerUniqueIdentity):
if not self.enabled: return
(err, ownID) = ts3lib.getClientID(schid)
if clientID != ownID: return
(err, val) = ts3lib.getClientNeededPermission(schid, "b_client_use_channel_commander")
if val: return
ts3lib.setClientSelfVariableAsInt(schid, ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER, 1)
ts3lib.flushClientSelfUpdates(schid, self.retcode)
def onServerPermissionErrorEvent(self, schid, errorMessage, error, returnCode, failedPermissionID):
if not self.enabled: return
print(self.name, "returnCode", returnCode, "self.retcode", self.retcode)
if returnCode != self.retcode: return
# if failedPermissionID == 185: return True
return True
def onServerErrorEvent(self, schid, errorMessage, error, returnCode, extraMessage):
if not self.enabled: return
print(self.name, "returnCode", returnCode, "self.retcode", self.retcode)
if returnCode != self.retcode: return
print("test")
if error == ts3defines.ERROR_client_is_flooding:
ts3lib.printMessageToCurrentTab("{}: [color=red][b]Client is flooding, stopping!".format(self.name))
self.timer.stop()
return True
elif error == ts3defines.ERROR_ok:
return True
class dynamicAvatar(ts3plugin):
shortname = "AC"
name = "Dynamic Avatar Changer"
requestAutoload = False
version = "1.0"
apiVersion = 22
author = "Bluscream"
description = "Changes your avatar for you."
offersConfigure = True
commandKeyword = ""
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0,
"Refresh avatar",
path.join(ts3lib.getPluginPath(), "pyTSon", "scripts",
"dynamicAvatar", "gfx", "manual.png")),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1,
"Toggle Timer", '')]
hotkeys = []
ini = path.join(getPluginPath(), "scripts", "dynamicAvatar",
"settings.ini")
config = ConfigParser()
timer = QTimer()
int = 0
def timestamp(self):
return '[{:%Y-%m-%d %H:%M:%S}] '.format(datetime.now())
def __init__(self):
if path.isfile(self.ini): self.config.read(self.ini)
else:
self.config['GENERAL'] = {
"debug": "False",
"imgurl": "",
"imgpath": "",
"mode": "url",
"refresh": "60"
}
with open(self.ini, 'w') as configfile:
self.config.write(configfile)
self.timer.timeout.connect(self.tick)
if self.config.getboolean('GENERAL', 'debug'):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(self.timestamp(), self.name, self.author))
def tick(self, schid=0):
schid = ts3lib.getCurrentServerConnectionHandlerID()
self.int += 1
ts3lib.printMessageToCurrentTab('Tick %s' % self.int)
if self.config.get('GENERAL', 'mode') == 'url': self.urlAvatar(schid)
else: self.pathAvatar(schid)
def configure(self, qParentWidget):
try:
self.dlg = SettingsDialog(self)
self.dlg.show()
except:
from traceback import format_exc
try:
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon::" + self.name, 0)
except:
print("Error in " + self.name + ".configure: " + format_exc())
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
try:
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
if menuItemID == 0:
if self.config.get('GENERAL', 'mode') == "url":
self.urlAvatar(schid)
elif self.config.get('GENERAL', 'mode') == "path":
self.pathAvatar(schid)
elif menuItemID == 1:
if self.timer.isActive():
self.timer.stop()
ts3lib.printMessageToCurrentTab('Timer stopped!')
else:
self.timer.start(
int(self.config.get('GENERAL', 'refresh')) * 1000)
ts3lib.printMessageToCurrentTab('Timer started!')
except:
try:
from traceback import format_exc
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
try:
from traceback import format_exc
print(format_exc())
except:
print("Unknown Error")
def urlAvatar(self, schid):
try:
self.nwm = QNetworkAccessManager()
self.nwm.connect("finished(QNetworkReply*)", self.onNetworkReply)
self.schid = schid
print("%s" % self.config.get('GENERAL', 'imgurl'))
self.nwm.get(
QNetworkRequest(QUrl(self.config.get('GENERAL', 'imgurl'))))
except:
from traceback import format_exc
try:
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
print(format_exc())
def onNetworkReply(
self, reply
): #http://stackoverflow.com/questions/41712636/qnetworkrequest-for-generated-images
try:
print("Error: %s (%s)" % (reply.error(), reply.errorString()))
print("Content-Type: %s" %
reply.header(QNetworkRequest.ContentTypeHeader))
try:
print("Content: %s" % reply.readAll())
except:
pass
#if reply.header(QNetworkRequest.ContentTypeHeader) == "image/jpeg":
imgraw = reply.readAll() #.data()#.decode('utf-8')
temp_dir = gettempdir()
filename = self.generateAvatarFileName(self.schid)
tmp = path.join(temp_dir, filename)
fn = QFile(tmp)
fn.open(QIODevice.WriteOnly)
fn.write(imgraw)
fn.close
#with open(tmp, 'wb') as f: f.write(imgraw)
ts3lib.logMessage("Uploading %s as new avatar." % tmp,
ts3defines.LogLevel.LogLevel_INFO,
"PyTSon Script", 0)
self.uploadAvatar(self.schid, tmp, filename)
except:
from traceback import format_exc
try:
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
print(format_exc())
reply.deleteLater()
def pathAvatar(self, schid):
try:
_path = self.config.get('GENERAL', 'imgpath')
img = path.join(
_path,
random.choice([
x for x in listdir(_path)
if path.isfile(path.join(_path, x))
]))
if not self.getFileExtension(img) in [
'bmp', 'gif', 'jpeg', 'jpg', 'pbm', 'pgm', 'png', 'ppm',
'xbm', 'xpm', None
]:
self.pathAvatar(schid)
return
temp_dir = gettempdir()
filename = self.generateAvatarFileName(schid)
tmp = path.join(temp_dir, filename)
copy2(img, tmp)
ts3lib.logMessage("Uploading %s as new avatar." % img,
ts3defines.LogLevel.LogLevel_INFO,
"PyTSon Script", 0)
self.uploadAvatar(schid, tmp, filename)
except:
from traceback import format_exc
try:
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
print(format_exc())
def uploadAvatar(self, schid, img, filename=""):
try:
img = path.abspath(img)
self.tmp = img
if filename == "": filename = self.generateAvatarFileName(schid)
imgdir = path.dirname(img) + path.sep
self.retcode = ts3lib.createReturnCode()
(error, ftid) = ts3lib.sendFile(schid, 0, "",
"/avatar/" + filename, True, False,
imgdir, self.retcode)
except:
try:
from traceback import format_exc
ts3lib.logMessage(format_exc(),
ts3defines.LogLevel.LogLevel_ERROR,
"PyTSon Script", 0)
except:
try:
from traceback import format_exc
print(format_exc())
except:
print("Unknown Error")
def setAvatar(self, schid, img):
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientPropertiesRare.CLIENT_FLAG_AVATAR,
self.getMd5FromFile(img))
ts3lib.flushClientSelfUpdates(schid)
def generateAvatarFileName(self, schid):
(error, ownID) = ts3lib.getClientID(schid)
(error, ownUID) = ts3lib.getClientVariableAsString(
schid, ownID, ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
ownUID = ownUID.encode('ascii')
return "avatar_" + b64encode(ownUID).decode("ascii").split('=')[0]
def getMd5FromFile(self, file):
hash_md5 = md5()
with open(file, "rb") as f:
#f = iopen(file, 'rb')
for chunk in iter(lambda: f.read(4096), b""):
hash_md5.update(chunk)
#f.close()
return hash_md5.hexdigest()
def getFileExtension(self, filename):
basename = path.basename(filename) # os independent
ext = '.'.join(basename.split('.')[1:])
return ext if ext else None
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if hasattr(self, "retcode") and self.retcode == returnCode:
self.retcode = None
self.setAvatar(schid, self.tmp)
try:
remove(self.tmp)
self.tmp = None
except:
QTimer.singleShot(500, self.deltmp)
def deltmp(self):
try:
f = iopen(self.tmp)
f.close()
except:
pass
try:
remove(self.tmp)
self.tmp = None
except:
QTimer.singleShot(1000, self.tmp)
# def onFileTransferStatusEvent(self, ftid, status, statusMessage, remotefileSize, schid): # Doesn't work in pyTSon
# try:
# print("test")
# print(str("#"+ftid+": "+status))
# except:
# try: from traceback import format_exc;ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "PyTSon Script", 0)
# except:
# try: from traceback import format_exc;print(format_exc())
# except: print("Unknown Error")
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
if ts3lib.getServerVariableAsString(
schid, ts3defines.VirtualServerProperties.
VIRTUALSERVER_UNIQUE_IDENTIFIER
) == "QTRtPmYiSKpMS8Oyd4hyztcvLqU=":
return
# if not self.timer.isActive(): self.timer.start(int(self.config.get('GENERAL', 'refresh'))*1000);
elif newStatus == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
if self.timer.isActive(): self.timer.stop()
class antiAFK(ts3plugin):
name = "Anti AFK"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 21
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Never get moved by being AFK again."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0,
"Toggle " + name, "")]
hotkeys = []
timer = QTimer()
servers = {}
text = "."
interval = (10, 30)
retcode = ""
hook = False
def __init__(self):
addons = getAddons()
for k in addons:
if addons[k]["name"] == "TS3Hook":
self.hook = True
break
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
for schid in self.servers:
self.delTimer(schid)
def addTimer(self, schid):
err, clid = ts3lib.getClientID(schid)
self.servers[schid] = {"clid": clid}
if len(self.servers) == 1:
self.timer.start(
randint(self.interval[0] * 1000, self.interval[1] * 1000))
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, "> Added Timer:", self.servers[schid], "for #",
schid, "(servers:",
len(self.servers) - 1, ")")
def delTimer(self, schid):
if schid in self.servers:
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, "> Removing Timer:", self.servers[schid],
"for #", schid, "(servers:",
len(self.servers) - 1, ")")
del self.servers[schid]
if len(self.servers) == 0: self.timer.stop()
def tick(self):
for schid in self.servers:
if self.hook: sendCommand(self.name, "clientupdate", schid)
else:
self.retcode = ts3lib.createReturnCode()
ts3lib.requestSendPrivateTextMsg(schid, self.text,
self.servers[schid]["clid"],
self.retcode)
self.timer.setInterval(
randint(self.interval[0] * 1000, self.interval[1] * 1000))
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL or menuItemID != 0:
return
if schid in self.servers: self.delTimer(schid)
else: self.addTimer(schid)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
self.delTimer(schid)
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName,
fromUniqueIdentifier, message, ffIgnored):
if schid in self.servers and fromID == self.servers[schid][
"clid"] and targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT and message == self.text:
return 1
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if returnCode == self.retcode:
self.retcode = ""
return True
class customBadges(ts3plugin):
name = "Custom Badges"
try: apiVersion = getCurrentApiVersion()
except: apiVersion = 21
requestAutoload = False
version = "0.9.3.1"
author = "Bluscream"
description = "Automatically sets some badges for you :)"
offersConfigure = True
commandKeyword = ""
infoTitle = "[b]Badges[/b]"
menuItems = [
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0, "Change " + name, "")#,
#(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1, "Generate Badge UIDs", "")
]
hotkeys = []
icons = path.join(ts3lib.getConfigPath(), "cache", "badges")
ini = path.join(getPluginPath(), "scripts", "customBadges", "settings.ini")
ui = path.join(getPluginPath(), "scripts", "customBadges", "badges.ui")
badges_ext = path.join(getPluginPath(), "include", "badges_ext.json")
badges_ext_remote = "https://raw.githubusercontent.com/R4P3-NET/CustomBadges/master/badges.json"
cfg = ConfigParser()
dlg = None
cfg["general"] = {
"cfgversion": "1",
"debug": "False",
"enabled": "True",
"badges": "",
"overwolf": "False",
"lastnotice": ""
}
badges = {}
extbadges = {}
notice = QTimer()
notice_nwmc = QNetworkAccessManager()
def __init__(self):
try:
loadCfg(self.ini, self.cfg)
(tstamp, self.badges, array) = loadBadges()
self.requestBadgesExt()
self.notice.timeout.connect(self.checkNotice)
self.notice.start(30*1000) # 180
if PluginHost.cfg.getboolean("general", "verbose"): ts3lib.printMessageToCurrentTab("{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded.".format(timestamp(), self.name, self.author))
except: ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "pyTSon", 0)
def infoData(self, schid, id, atype):
if atype != ts3defines.PluginItemType.PLUGIN_CLIENT: return None
(err, ownID) = ts3lib.getClientID(schid)
if ownID != id: return None
# overwolf = self.cfg.getboolean('general', 'overwolf')
# badges = self.cfg.get('general', 'badges').split(',')
(err, badges) = ts3lib.getClientVariable(schid, id, ts3defines.ClientPropertiesRare.CLIENT_BADGES)
(overwolf, badges) = parseBadges(badges)
_return = ["Overwolf: {0}".format("[color=green]Yes[/color]" if overwolf else "[color=red]No[/color]")]
# i = []
# for badge in badges:
# if badge
for badge in badges:
lst = self.badges
if badge in self.extbadges: lst = self.extbadges
_return.append("{} {}".format(
"[img]https://badges-content.teamspeak.com/{}/{}.svg[/img]".format(badge, lst[badge]["filename"] if badge in lst else "unknown"),
self.badgeNameByUID(badge, lst) if badge in lst else badge
))
return _return
def saveBadges(self, external):
db = ts3client.Config()
query = QSqlQuery(db)
(timestamp, internal, array) = loadBadges()
delimiter = array.mid(0, 12)
delimiter1 = 0;delimiter2 = 0;delimiter3 = 0;delimiter4 = 0
guid_len = 0;guid = ""
name_len = 0;name = ""
url_len = 0;url = ""
desc_len = 0;desc = ""
for i in range(0, array.size()):
if i == 12: #guid_len
guid_len = int(array.at(i))
guid = str(array.mid(i+1, guid_len))
elif i == (12 + 1 + guid_len + 1):
delimiter1 = array.mid(i - 1,i - 1)
name_len = int(array.at(i))
name = str(array.mid(i+1, name_len))
elif i == (12 + 1 + guid_len + 1 + name_len + 2):
delimiter2 = array.mid(i - 1,i - 1)
url_len = int(array.at(i))
url = str(array.mid(i+1, url_len))
elif i == (12 + 1 + guid_len + 1 + name_len + 2 + url_len + 2):
delimiter3 = array.mid(i - 3,i - 3)
delimiter4 = array.mid(i+desc_len,i+desc_len)
desc_len = int(array.at(i))
desc = str(array.mid(i+1, desc_len))
break
print("delimiter:", delimiter.toHex())
print("delimiter1:", delimiter1.toHex())
print("delimiter2:", delimiter2.toHex())
print("delimiter3:", delimiter3.toHex())
print("delimiter4:", delimiter4.toHex())
print("array:", array.toHex())
# query.prepare( "UPDATE Badges (BadgesListData) VALUES (:byteArray)" );
# query.bindValue( ":imageData", array);
def badgeNameByUID(self, uid, lst=badges):
for badge in lst:
if badge == uid: return lst[badge]["name"]
def requestBadgesExt(self):
try:
with open(self.badges_ext, encoding='utf-8-sig') as json_file:
self.extbadges = load(json_file)
except:
self.nwmc_ext = QNetworkAccessManager()
self.nwmc_ext.connect("finished(QNetworkReply*)", self.loadBadgesExt)
self.nwmc_ext.get(QNetworkRequest(QUrl(self.badges_ext_remote)))
def loadBadgesExt(self, reply):
try:
data = reply.readAll().data().decode('utf-8')
self.extbadges = loads(data)
except: ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "pyTSon", 0)
def checkNotice(self):
self.notice_nwmc.connect("finished(QNetworkReply*)", self.loadNotice)
self.notice_nwmc.get(QNetworkRequest(QUrl("https://raw.githubusercontent.com/R4P3-NET/CustomBadges/master/notice")))
def loadNotice(self, reply):
data = reply.readAll().data().decode('utf-8')
if data.strip() == "" or data == self.cfg.get('general', 'lastnotice'): return
msgBox(data, 0, "{} Notice!".format(self.name))
self.cfg.set('general', 'lastnotice', data)
def stop(self):
saveCfg(self.ini, self.cfg)
self.notice.stop()
def configure(self, qParentWidget):
self.openDialog()
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL: return
if menuItemID == 0: self.openDialog()
elif menuItemID == 1:
self.saveBadges(self.extbadges)
for i in range(0,3):
# 0c4u2snt-ao1m-7b5a-d0gq-e3s3shceript
uid = [random_string(size=8, chars=string.ascii_lowercase + string.digits)]
for _i in range(0,3):
uid.append(random_string(size=4, chars=string.ascii_lowercase + string.digits))
uid.append(random_string(size=12, chars=string.ascii_lowercase + string.digits))
ts3lib.printMessageToCurrentTab("[color=red]Random UID #{}: [b]{}".format(i, '-'.join(uid)))
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
self.setCustomBadges()
def setCustomBadges(self):
try:
overwolf = self.cfg.getboolean('general', 'overwolf')
badges = self.cfg.get('general', 'badges').split(",")
# if len(badges) > 0: badges += ['0c4u2snt-ao1m-7b5a-d0gq-e3s3shceript']
(err, schids) = ts3lib.getServerConnectionHandlerList()
for schid in schids:
sendCommand(self.name, buildBadges(badges, overwolf), schid)
except: ts3lib.logMessage(format_exc(), ts3defines.LogLevel.LogLevel_ERROR, "pyTSon", 0)
def openDialog(self):
if not self.dlg: self.dlg = BadgesDialog(self)
self.dlg.show()
self.dlg.raise_()
self.dlg.activateWindow()
class antiAFK(ts3plugin):
path = getScriptPath(__name__)
name = "Anti AFK"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 21
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Never get moved by being AFK again."
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0,
"Toggle " + name, "")]
hotkeys = []
timer = QTimer()
servers = {}
text = "." #~cmdclientupdate
interval = {
"9Sx6wrlRV4i9klBiTanrksNFKvs=": (5, 10),
"QTRtPmYiSKpMS8Oyd4hyztcvLqU=": (30, 120),
"default": (10, 30)
}
retcode = ""
hook = False
def __init__(self):
addons = getAddons()
for k in addons:
if addons[k]["name"] == "TS3Hook":
self.hook = True
break
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
for schid in self.servers:
self.delTimer(schid)
def addTimer(self, schid):
err, clid = ts3lib.getClientID(schid)
self.servers[schid] = {"clid": clid}
interval = self.getInterval(schid)
if len(self.servers) == 1:
self.timer.start(interval["interval"])
ts3lib.printMessageToCurrentTab(
"{}> Enabled for tab #{} with interval {} (server uid: {})".format(
self.name, schid, interval["interval"], interval["suid"]))
def getInterval(self, schid=0):
if schid < 1: schid = ts3lib.getCurrentServerConnectionHandlerID()
(err, suid) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_UNIQUE_IDENTIFIER)
if not suid in self.interval: suid = "default"
min = self.interval[suid][0] * 1000
max = self.interval[suid][1] * 1000
_return = {
"schid": schid,
"suid": suid,
"min": min,
"max": max,
"interval": randint(min, max)
}
if PluginHost.cfg.getboolean("general", "verbose"): print(_return)
return _return
def delTimer(self, schid):
if schid in self.servers:
# print(self.name, "> Removing Timer:", self.servers[schid], "for #", schid, "(servers:", len(self.servers)-1,")")
del self.servers[schid]
if len(self.servers) == 0: self.timer.stop()
ts3lib.printMessageToCurrentTab("{}> Disabled for tab #{}".format(
self.name, schid))
def tick(self):
for schid in self.servers:
if self.hook: sendCommand(self.name, "clientupdate", schid)
else:
self.retcode = ts3lib.createReturnCode()
ts3lib.requestSendPrivateTextMsg(schid, self.text,
self.servers[schid]["clid"],
self.retcode)
interval = self.getInterval()
# print(self.name, ">", "Sent", self.text, "for schid", schid, "to clid", self.servers[schid]["clid"], "| new interval:", interval)
self.timer.setInterval(interval)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL or menuItemID != 0:
return
if schid in self.servers: self.delTimer(schid)
else: self.addTimer(schid)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
self.delTimer(schid)
def onTextMessageEvent(self, schid, targetMode, toID, fromID, fromName,
fromUniqueIdentifier, message, ffIgnored):
if schid in self.servers and fromID == self.servers[schid][
"clid"] and targetMode == ts3defines.TextMessageTargetMode.TextMessageTarget_CLIENT and message == self.text:
return 1
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if returnCode == self.retcode: return True
def onServerPermissionErrorEvent(self, schid, errorMessage, error,
returnCode, failedPermissionID):
if returnCode == self.retcode: return True
class sessionRestore(ts3plugin):
path = getScriptPath(__name__)
name = "Session Restore"
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "Restores your last session on startup"
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = []
hotkeys = []
timer = QTimer()
delay = 500
increase = 2000
ts3host = None
tabs = {}
_delay = delay
_tabs = {}
_timers = []
backup_file = os.path.join(path, "session.json")
first = True
def __init__(self):
if "aaa_ts3Ext" in PluginHost.active:
ts3ext = PluginHost.active["aaa_ts3Ext"]
self.tabs = ts3ext.tabs
ts3lib.logMessage("{}: Dependency loaded".format(self.name),
LogLevel.LogLevel_WARNING, "pyTSon", 0)
log(
self, LogLevel.LogLevel_DEBUG,
"[color=orange]{name}[/color] Plugin for pyTSon by [url=https://github.com/{author}]{author}[/url] loaded."
.format(name=self.name, author=self.author), 0)
else:
retry = 1000
self.timer.singleShot(retry, self.__init__)
ts3lib.logMessage(
"{}: Dependency not yet loaded, retrying in {} second(s)!".
format(self.name,
retry / 1000), LogLevel.LogLevel_WARNING, "pyTSon", 0)
def stop(self):
if hasattr(self, "timer"):
if self.timer.isActive(): self.timer.stop()
def saveTabs(self):
tabs = {} # Todo: OrderedDict
for tab in self.tabs:
if self.tabs[tab][
"status"] == ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
tabs[tab] = self.tabs[tab]
if not len(tabs): return
with open(self.backup_file, 'w') as outfile:
dump(tabs, outfile)
def restoreTabs(self):
try:
err, schids = ts3lib.getServerConnectionHandlerList()
if err != ERROR_ok: return
if len(schids) > 1: return
for schid in schids:
(err, status) = ts3lib.getConnectionStatus(schid)
if err != ERROR_ok: return
if status != ConnectStatus.STATUS_DISCONNECTED: return
self._tabs = {}
self._timers = []
with open(self.backup_file) as f:
self._tabs = load(f)
i = 0
self._delay = self.delay
for tab in self._tabs:
i += 1
# if self._tabs[tab]["status"] == ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
timer = QTimer()
self._timers.append(timer)
timer.singleShot(self._delay, self.restoreTab)
# self.restoreTab(tab)
self._delay += self.increase
except:
ts3lib.logMessage(format_exc(), LogLevel.LogLevel_ERROR, "pyTSon",
0)
def restoreTab(self, tab=None):
try:
if not tab:
self._timers.pop(0)
schid, tab = self._tabs.popitem()
args = [
PluginConnectTab.PLUGIN_CONNECT_TAB_NEW_IF_CURRENT_CONNECTED
if self.first else
PluginConnectTab.PLUGIN_CONNECT_TAB_NEW, # connectTab: int,
tab["name"], # serverLabel: Union[str, unicode],
tab["address"], # serverAddress: Union[str, unicode],
tab["pw"], # serverPassword: Union[str, unicode],
tab["nick"], # nickname: Union[str, unicode],
tab["cpath"], # channel: Union[str, unicode],
tab["cpw"], # channelPassword: Union[str, unicode]
"", # captureProfile: Union[str, unicode],
"", # playbackProfile: Union[str, unicode]
"", # hotkeyProfile: Union[str, unicode],
"Default Sound Pack (Female)", # soundPack
tab["uid"], # userIdentity: Union[str, unicode],
tab["token"], # oneTimeKey: Union[str, unicode],
tab["nick_phonetic"] # phoneticName: Union[str, unicode]
]
if self.first: self.first = False
print("ts3lib.guiConnect({})".format("\", \"".join(
str(x) for x in args)))
err, schid = ts3lib.guiConnect(args[0], args[1], args[2], args[3],
args[4], args[5], args[6], args[7],
args[8], args[9], args[10],
args[11], args[12], args[13])
print("TAB: ", tab)
ts3lib.setClientSelfVariableAsInt(
schid, ClientProperties.CLIENT_INPUT_MUTED, tab["input_muted"])
ts3lib.setClientSelfVariableAsInt(
schid, ClientProperties.CLIENT_OUTPUT_MUTED,
int(tab["output_muted"]))
ts3lib.requestChannelSubscribeAll(schid)
except:
ts3lib.logMessage(format_exc(), LogLevel.LogLevel_ERROR, "pyTSon",
0)
def menuCreated(self):
if not self.first: return
self.timer.timeout.connect(self.saveTabs)
self.timer.setTimerType(2)
self.timer.start(5000)
self.restoreTabs()
def stop(self):
self.timer.stop()
self.timer = None
del self.timer
self.timer = QTimer()
class fakeClients(ts3plugin):
path = getPluginPath("scripts", __name__)
name = "Fake Clients"
apiVersion = 21
requestAutoload = False
version = "1"
author = "Bluscream"
description = ""
offersConfigure = False
commandKeyword = "fc"
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 1,
"Timeout", "scripts/%s/ping_4.svg" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 0,
"== Hacks ==", ""),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 1,
"Disconnect", "scripts/%s/disconnect.svg" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 2, "Kick",
"scripts/%s/kick_server.svg" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 3, "Ban",
"scripts/%s/ban_client.svg" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 4,
"Timeout", "scripts/%s/ping_4.svg" % __name__),
(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT, 5,
"== Hacks ==", "")]
hotkeys = []
timer = QTimer()
count = 1
fakeclients = []
def __init__(self):
self.timer.timeout.connect(self.tick)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def menuCreated(self):
if not self.name in PluginHost.active: return
for id in [0, 5]:
try:
ts3lib.setPluginMenuEnabled(PluginHost.globalMenuID(self, id),
False)
except:
pass
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_CLIENT:
(err, cid) = ts3lib.getChannelOfClient(schid, selectedItemID)
if menuItemID == 1:
sendCommand(
self.name,
"notifyclientleftview cfid={} ctid=0 reasonid=8 reasonmsg=disconnected clid={}"
.format(cid, selectedItemID), schid, True, True)
elif menuItemID == 2:
sendCommand(
self.name,
"notifyclientleftview cfid={} ctid=0 reasonid=5 reasonmsg=kicked clid={} invokerid=0 invokername=Server invokeruid"
.format(cid, selectedItemID), schid, True, True)
elif menuItemID == 3:
sendCommand(
self.name,
"notifyclientleftview cfid={} ctid=0 reasonid=6 reasonmsg=ban clid={} invokerid=0 invokername=Server invokeruid bantime=0"
.format(cid, selectedItemID), schid, True, True)
elif menuItemID == 4:
sendCommand(
self.name,
"notifyclientleftview cfid={} ctid=0 reasonid=3 reasonmsg=DDoS clid={}"
.format(cid, selectedItemID), schid, True, True)
elif atype == ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL:
for client in self.fakeclients:
sendCommand(
self.name,
"notifyclientleftview cfid={} ctid=0 reasonid=6 reasonmsg=ban clid={} invokerid=0 invokername=Server invokeruid bantime=0"
.format(client[1], client[0]), schid, True, True)
self.fakeclients = []
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
if oldChannelID != 0: return # if newChannelID == 0: return
(err, clid) = ts3lib.getClientID(schid)
if clientID == clid: return
(err, uid) = ts3lib.getClientVariable(
schid, clientID,
ts3defines.ClientProperties.CLIENT_UNIQUE_IDENTIFIER)
if uid and uid.startswith("FakeClient"): return
if getContactStatus(uid) != ContactStatus.FRIEND: return
sendCommand(
self.name,
"notifyclientupdated clid={} client_is_channel_commander=1".format(
clientID), schid, True, True
) # client_country=JP client_is_recording=1 client_platform=Windoof
def processCommand(self, schid, command):
clients = 1
try:
clients = int(command)
except:
pass
self.clients = []
# (err, clid) = ts3lib.getClientID(schid)
# (err, cid) = ts3lib.getChannelOfClient(schid, clid)
(err, clids) = ts3lib.getClientList(schid)
self.clients.extend(clids)
e, self.sgroup = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_SERVER_GROUP)
e, acg = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_GROUP)
e, dcg = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerPropertiesRare.
VIRTUALSERVER_DEFAULT_CHANNEL_ADMIN_GROUP)
self.cgroups = [acg, dcg]
timestamp, ret, badges = loadBadges()
self.badges = []
for badge in ret:
self.badges.append(badge)
if clients > 10:
self.i = 1
self.schid = schid
self.c = clients + 1
self.timer.start(2)
else:
for i in range(clients):
self.addClient(schid)
i += 1
return True
def tick(self):
if self.i >= self.c: self.timer.stop()
self.addClient(self.schid)
self.i += 1
def addClient(self, schid):
cmd = "notifycliententerview"
client = self.fakeClient(schid)
for k in client:
if client[k] != "":
cmd += " {}={}".format(k, client[k])
else:
cmd += " {}".format(k)
sendCommand(self.name, cmd, schid, True, True)
def fakeClient(self, schid):
client = {}
client["reasonid"] = "0"
client["cfid"] = "0"
(err, cids) = ts3lib.getChannelList(schid)
cid = choice(cids)
client["ctid"] = cid
client["client_channel_group_id"] = choice(self.cgroups)
client["client_servergroups"] = self.sgroup
client["client_channel_group_inherited_channel_id"] = cid
client["client_input_muted"] = randint(0, 1)
client["client_output_muted"] = randint(0, 1)
client["client_outputonly_muted"] = randint(0, 1)
client["client_input_hardware"] = randint(0, 1)
client["client_output_hardware"] = randint(0, 1)
client["client_is_recording"] = randint(0, 1)
client["client_talk_request"] = randint(0, 1)
client["client_type"] = 0 # randint(0,1)
client["client_is_talker"] = randint(0, 1)
client["client_away"] = randint(0, 1)
client["client_is_channel_commander"] = randint(0, 1)
client["client_is_priority_speaker"] = randint(0, 1)
clid = randint(0, 65000)
while clid in self.clients:
clid = randint(0, 65000)
client["clid"] = clid
client["client_database_id"] = randint(0, 1000)
client["client_talk_power"] = randint(0, 99999)
client["client_unread_messages"] = randint(0, 10)
client["client_needed_serverquery_view_power"] = 0 # randint(0,65000)
client["client_icon_id"] = "0" # = randint(0,65000)
client["client_unique_identifier"] = "FakeClient#{}".format(
self.count) # "{}=".format(random_string(27))
client["client_nickname"] = random_string(randint(3, 30))
client["client_meta_data"] = random_string(randint(0, 1)) # 30
client["client_away_message"] = random_string(randint(0, 10)) # 80
client["client_flag_avatar"] = "" # = random_string(1)
client["client_talk_request_msg"] = random_string(randint(0, 50))
client["client_description"] = random_string(randint(0, 50))
client["client_nickname_phonetic"] = random_string(randint(3, 30))
client["client_country"] = random_string(2).upper() # "DE" #
client["client_badges"] = "overwolf={}:badges={}".format(
randint(0, 1), choice(self.badges)) # random_string(randint(0,30))
self.count += 1
self.clients.append(clid)
self.fakeclients.append((clid, cid))
return client
class recordSpam(ts3plugin):
name = "Record Spam"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 22
requestAutoload = False
version = "1.0"
author = "Bluscream"
description = "( .) ( .)"
offersConfigure = False
commandKeyword = "rec"
infoTitle = None
menuItems = [(ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL, 0,
"Toggle " + name, "scripts/%s/record.svg" % __name__)]
hotkeys = [("request_talk_power", "Request Talk Power")]
timer = QTimer()
hook = False
schid = 0
tpr_name = "Talk Power bitte?"
def __init__(self):
addons = getAddons()
for k in addons:
if addons[k]["name"] == "TS3Hook":
self.hook = True
break
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
self.timer.stop()
def processCommand(self, schid, keyword):
self.onHotkeyOrCommandEvent(keyword, schid)
def onHotkeyEvent(self, keyword):
self.onHotkeyOrCommandEvent(keyword)
def onHotkeyOrCommandEvent(self, keyword, schid=0):
if not schid: schid = ts3lib.getCurrentServerConnectionHandlerID()
if keyword == "request_talk_power":
(err, oldnick) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME,
self.tpr_name)
ts3lib.flushClientSelfUpdates(schid)
if self.hook:
sendCommand(self.name, "clientupdate client_is_recording=1",
schid)
sendCommand(self.name, "clientupdate client_is_recording=0",
schid)
else:
ts3lib.startVoiceRecording(schid)
ts3lib.stopVoiceRecording(schid)
ts3lib.setClientSelfVariableAsString(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME, oldnick)
ts3lib.flushClientSelfUpdates(schid)
def onServerUpdatedEvent(self, schid):
if not self.schid == schid: return
self.timer.start(
calculateInterval(schid, AntiFloodPoints.CLIENTUPDATE * 2,
self.name))
def startVoiceRecording(self, schid):
if self.hook:
sendCommand(self.name, "clientupdate client_is_recording=1", schid)
else:
# ts3lib.setClientSelfVariableAsInt(schid, ts3defines.ClientProperties.CLIENT_IS_RECORDING, True)
ts3lib.startVoiceRecording(schid)
def stopVoiceRecording(self, schid):
if self.hook:
sendCommand(self.name, "clientupdate client_is_recording=0", schid)
else:
# ts3lib.setClientSelfVariableAsInt(schid, ts3defines.ClientProperties.CLIENT_IS_RECORDING, False)
ts3lib.stopVoiceRecording(schid)
def tick(self):
if not self.schid or self.schid < 1: self.timer.stop()
if self.hook:
sendCommand(self.name, "clientupdate client_is_recording=1",
self.schid)
sendCommand(self.name, "clientupdate client_is_recording=0",
self.schid)
else:
ts3lib.startVoiceRecording(self.schid)
ts3lib.stopVoiceRecording(self.schid)
def onMenuItemEvent(self, schid, atype, menuItemID, selectedItemID):
if atype != ts3defines.PluginMenuType.PLUGIN_MENU_TYPE_GLOBAL or menuItemID != 0:
return
if self.timer.isActive():
self.timer.stop()
self.schid = 0
else:
interval = inputInt(self.name, 'Interval in Milliseconds:')
self.schid = schid
if interval < 1: ts3lib.requestServerVariables(schid)
else: self.timer.start(interval)
def onServerErrorEvent(self, schid, errorMessage, error, returnCode,
extraMessage):
if not self.timer.isActive(): return
if error == ts3defines.ERROR_client_is_flooding:
ts3lib.printMessageToCurrentTab(
"{}: [color=red][b]Client is flooding, stopping!".format(
self.name))
self.timer.stop()
if self.hook:
sendCommand(self.name, "clientupdate client_is_recording=0",
self.schid)
else:
ts3lib.stopVoiceRecording(self.schid)
return True
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
if newStatus != ts3defines.ConnectStatus.STATUS_DISCONNECTED: return
if schid != self.schid: return
return
self.timer.stop()
self.schid = 0
class discordify(ts3plugin):
name = "Discord Rich Presence"
try:
apiVersion = getCurrentApiVersion()
except:
apiVersion = 22
requestAutoload = True
version = "1.0"
author = "Bluscream"
description = "Show off your big Teamspeak c**k on Discord"
offersConfigure = False
commandKeyword = ""
infoTitle = None
menuItems = []
hotkeys = []
discord = None
update = False
timer = QTimer()
tabs = {}
activity = {
"details": "Disconnected",
"timestamps": {},
"assets": {
"large_text": "TeamSpeak 3",
"large_image": "logo"
}
}
def __init__(self):
try:
import unidecode
except ImportError:
PluginInstaller().installPackages(['unidecode'])
try:
from discoIPC import ipc
except ImportError:
PluginInstaller().installPackages(['discoIPC'])
from discoIPC import ipc
self.discord = ipc.DiscordIPC(
"504997049226362891") # 450824928841957386
try:
self.discord.connect()
except:
ts3lib.logMessage("Discord not running!",
ts3defines.LogLevel.LogLevel_WARNING,
"pyTSon Discord Rich Presence", 0)
self.timer.timeout.connect(self.tick)
self.timer.setTimerType(2)
schid = ts3lib.getCurrentServerConnectionHandlerID()
self.onTabChangedEvent(schid)
self.timer.start(1000)
"""
(err, status) = ts3lib.getConnectionStatus(schid)
if status == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
self.updateServer(schid); self.updateChannel(schid); self.updateVoice(schid);self.updateClient(schid)
"""
if PluginHost.cfg.getboolean("general", "verbose"):
ts3lib.printMessageToCurrentTab(
"{0}[color=orange]{1}[/color] Plugin for pyTSon by [url=https://github.com/{2}]{2}[/url] loaded."
.format(timestamp(), self.name, self.author))
def stop(self):
self.timer.stop()
if self.discord.connected: self.discord.disconnect()
def tick(self):
if not self.update: return
try:
if not self.discord.connected: self.discord.connect()
self.discord.update_activity(self.activity)
except:
pass
self.update = False
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, "updated:", self.activity)
def currentServerConnectionChanged(self, schid):
self.onTabChangedEvent(schid)
def onConnectStatusChangeEvent(self, schid, newStatus, errorNumber):
curschid = ts3lib.getCurrentServerConnectionHandlerID()
if curschid == schid: self.onTabChangedEvent(schid, newStatus)
def onTabChangedEvent(self, schid, status=None):
if status is None: (err, status) = ts3lib.getConnectionStatus(schid)
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, schid, status)
if status == ts3defines.ConnectStatus.STATUS_DISCONNECTED:
if schid in self.tabs:
del self.tabs[schid]
start = time()
self.activity["timestamps"]["start"] = start
self.activity["details"] = "Disconnected"
self.activity["state"] = ""
if hasattr(self.activity, "party"): del self.activity["party"]
self.activity["assets"] = {
"small_text": "Disconnected",
"small_image": "",
"large_text": "TeamSpeak 3",
"large_image": "logo"
}
self.update = True
elif status == ts3defines.ConnectStatus.STATUS_CONNECTION_ESTABLISHED:
if schid in self.tabs:
self.activity["timestamps"]["start"] = self.tabs[schid]
else:
start = time()
self.tabs[schid] = start
if PluginHost.cfg.getboolean("general", "verbose"):
print(self.name, "self.tabs[schid]", self.tabs[schid])
self.activity["timestamps"]["start"] = start
self.updateServer(schid)
self.updateChannel(schid)
self.updateVoice(schid)
self.updateClient(schid)
def updateServer(self, schid, ownID=0):
from unidecode import unidecode
if not ownID: (err, ownID) = ts3lib.getClientID(schid)
(err, name) = ts3lib.getServerVariable(
schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_NAME)
self.activity["details"] = unidecode(name)
server_type = getServerType(schid)
if server_type == ServerInstanceType.TEASPEAK:
self.activity["assets"]["large_text"] = "TeaSpeak"
self.activity["assets"]["large_image"] = "teaspeak"
elif server_type == ServerInstanceType.VANILLA:
self.activity["assets"]["large_text"] = "TeamSpeak 3"
self.activity["assets"]["large_image"] = "teamspeak"
elif server_type == ServerInstanceType.SDK:
self.activity["assets"]["large_text"] = "TeamSpeak 3 SDK"
self.activity["assets"]["large_image"] = "teamspeak"
else:
self.activity["assets"]["large_text"] = "Unknown"
self.activity["assets"]["large_image"] = "broken_image"
self.update = True
def updateChannel(self, schid, ownID=0, ownCID=0):
if not ownID: (err, ownID) = ts3lib.getClientID(schid)
if not ownCID: (err, ownCID) = ts3lib.getChannelOfClient(schid, ownID)
(err, cname) = ts3lib.getChannelVariable(
schid, ownCID, ts3defines.ChannelProperties.CHANNEL_NAME)
name = re.sub(r'^\[[crl\*]spacer(.*)?\]',
'',
cname,
flags=re.IGNORECASE | re.UNICODE)
from unidecode import unidecode
self.activity["state"] = unidecode(name)
clients = len(ts3lib.getChannelClientList(schid, ownCID)[1])
# (err, clients) = ts3lib.getChannelVariable(schid, ts3defines.ChannelPropertiesRare.)
(err, cmax) = ts3lib.getChannelVariable(
schid, ownCID, ts3defines.ChannelProperties.CHANNEL_MAXCLIENTS)
if cmax >= clients:
if PluginHost.cfg.getboolean("general", "verbose"):
print("cmax", cmax, ">=", "clients", clients)
self.activity["party"]["size"] = [clients, cmax]
else:
(err, smax) = ts3lib.getServerVariable(
schid,
ts3defines.VirtualServerProperties.VIRTUALSERVER_MAXCLIENTS)
# (err, clients) = ts3lib.getServerVariable(schid, ts3defines.VirtualServerProperties.VIRTUALSERVER_CLIENTS_ONLINE)
# clients = len(ts3lib.getClientList(schid)[1])
self.activity["party"] = {"size": [clients, smax]}
(err, ip) = ts3lib.getConnectionVariable(
schid, ownID, ts3defines.ConnectionProperties.CONNECTION_SERVER_IP)
(err, port) = ts3lib.getConnectionVariable(
schid, ownID,
ts3defines.ConnectionProperties.CONNECTION_SERVER_PORT)
self.activity["secrets"] = {
"join": "ts3server://{}?port={}&cid={}".format(ip, port, ownCID)
}
self.update = True
def updateClient(self, schid):
(err, name) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_NICKNAME)
from unidecode import unidecode
self.activity["assets"]["large_text"] = unidecode(name)
def updateVoice(self, schid, status=None):
curschid = ts3lib.getCurrentServerConnectionHandlerID()
if schid != curschid: return
if not status:
(err, status) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_FLAG_TALKING)
(err, afk) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientPropertiesRare.CLIENT_AWAY)
(err, output_activated) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_OUTPUT_HARDWARE)
(err, output_muted) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_OUTPUT_MUTED)
(err, input_activated) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_INPUT_HARDWARE)
(err, input_muted) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientProperties.CLIENT_INPUT_MUTED)
(err, commander) = ts3lib.getClientSelfVariable(
schid, ts3defines.ClientPropertiesRare.CLIENT_IS_CHANNEL_COMMANDER)
if PluginHost.cfg.getboolean("general", "verbose"):
print("CLIENT_AWAY", afk, "CLIENT_OUTPUT_HARDWARE",
output_activated, "CLIENT_OUTPUT_MUTED", output_muted,
"CLIENT_INPUT_HARDWARE", input_activated,
"CLIENT_INPUT_MUTED", input_muted)
if afk:
self.activity["assets"]["small_text"] = "Away From Keyboard"
self.activity["assets"]["small_image"] = "away"
self.update = True
elif not output_activated:
self.activity["assets"]["small_text"] = "Output Deactivated"
self.activity["assets"]["small_image"] = "hardware_output_muted"
self.update = True
elif output_muted:
self.activity["assets"]["small_text"] = "Output Muted"
self.activity["assets"]["small_image"] = "output_muted"
self.update = True
elif not input_activated:
self.activity["assets"]["small_text"] = "Input Deactivated"
self.activity["assets"]["small_image"] = "hardware_input_muted"
self.update = True
elif input_muted:
self.activity["assets"]["small_text"] = "Input Muted"
self.activity["assets"]["small_image"] = "input_muted"
self.update = True
elif status and commander:
self.activity["assets"][
"small_text"] = "Talking with Channel Commander"
self.activity["assets"]["small_image"] = "player_commander_on"
self.update = True
elif status and not commander:
self.activity["assets"]["small_text"] = "Talking"
self.activity["assets"]["small_image"] = "player_on"
self.update = True
elif not status and commander:
self.activity["assets"]["small_text"] = "Silent"
self.activity["assets"]["small_image"] = "player_commander_off"
self.update = True
elif not status and not commander:
self.activity["assets"]["small_text"] = "Silent"
self.activity["assets"]["small_image"] = "player_off"
self.update = True
def onClientSelfVariableUpdateEvent(self, schid, flag, oldValue, newValue):
props = ts3defines.ClientProperties
rare = ts3defines.ClientPropertiesRare
if flag in [
props.CLIENT_OUTPUT_HARDWARE, props.CLIENT_OUTPUT_MUTED,
props.CLIENT_INPUT_DEACTIVATED, props.CLIENT_INPUT_HARDWARE,
props.CLIENT_INPUT_MUTED, rare.CLIENT_IS_CHANNEL_COMMANDER,
rare.CLIENT_AWAY
]:
self.updateVoice(schid)
elif flag == props.CLIENT_NICKNAME:
self.updateClient(schid)
def onClientMoveEvent(self, schid, clientID, oldChannelID, newChannelID,
visibility, moveMessage):
(err, ownID) = ts3lib.getClientID(schid)
if ownID == clientID: self.updateChannel(schid, ownID)
def onClientMoveMovedEvent(self, schid, clientID, oldChannelID,
newChannelID, visibility, moverID, moverName,
moverUniqueIdentifier, moveMessage):
(err, ownID) = ts3lib.getClientID(schid)
if ownID == clientID: self.updateChannel(schid, ownID)
def onClientKickFromChannelEvent(self, schid, clientID, oldChannelID,
newChannelID, visibility, kickerID,
kickerName, kickerUniqueIdentifier,
kickMessage):
(err, ownID) = ts3lib.getClientID(schid)
if ownID == clientID: self.updateChannel(schid, ownID)
def onTalkStatusChangeEvent(self, schid, status, isReceivedWhisper,
clientID):
(err, ownID) = ts3lib.getClientID(schid)
if ownID == clientID: self.updateVoice(schid, status)
