def symmetric_triangle(n: int = None, **kwargs: dict) -> Optional[List[int]]:
"""Symmetric Triangle with n >= 2
Returns a numpy array of the nth row of Symmetric Triangle.
n=4 => triangle: [1, 2, 2, 1]
=> weighted: [0.16666667 0.33333333 0.33333333 0.16666667]
"""
n = int(npFabs(n)) if n is not None else 2
triangle = None
if n == 2:
triangle = [1, 1]
if n > 2:
if n % 2 == 0:
front = [i + 1 for i in range(0, mfloor(n / 2))]
triangle = front + front[::-1]
else:
front = [i + 1 for i in range(0, mfloor(0.5 * (n + 1)))]
triangle = front.copy()
front.pop()
triangle += front[::-1]
if kwargs.pop("weighted", False) and isinstance(triangle, list):
triangle_sum = npSum(triangle)
triangle_weights = triangle / triangle_sum
return triangle_weights
return triangle
async def user_xp(message, client, arguments):
# For user request
if len(arguments) == 0:
# Calculating xp and level
response = users_get_xp(message.author.id)
levels = level_check_command(message.author.id)
progress = str(mfloor((levels[2] / levels[3])*100))
await client.send_message(message.channel, ":b: **| " + message.author.name + " you are level "+str(levels[1])+" and you have " + str(response[0]) + " xp in total! "+progress+"% done on the current level!**")
# user request on others
if len(arguments) == 1:
if not message.author.id in owners:
return
# Getting user
user = await get_user_instance(message, arguments[0])
# Getting xp and calculating level for id
response = users_get_xp(user.id)
levels = level_check_command(user.id)
progress = str(mfloor((levels[2] / levels[3])*100))
# Sending message
await client.send_message(message.channel, ":b: **| "+ user.name + " is level "+str(levels[1])+" and has " + str(response[0]) + " xp in total! "+progress+"% done on the current level!**")
async def tuplat(message, client, arguments):
if len(arguments) == 0:
# Getting stats
user = message.author
stats = users_get_roll_stats(message.author.id)
else:
user = await get_user_instance(message, arguments[0])
try:
stats = users_get_roll_stats(user.id)
except:
send(1, "No user found")
await client.send_message(message.channel, ":game_die: **| User not found!**")
return
# Name
if user.nick is None:
name = user.name
else:
name = user.nick
# name
user_mention = " for: " + name
# Calculating winrate
try:
win_rate = mfloor(int(stats[1]) / int(stats[0]) * 100)
except:
win_rate = "0"
# Memes
if stats[2] == 0:
memes = ""
else:
try:
memes = "\n:money_with_wings: Memes gained: {}".format(mfloor(stats[2]))
except:
memes = ""
# Tokens
if stats[3] == 0:
tokens = ""
else:
try:
tokens = "\n:trophy: Tokens gained: {}".format(mfloor(stats[3]))
except:
tokens = ""
# Creating message
letter = ":game_die: **| Roll stats{}\n\n:arrows_counterclockwise: Rolled: {}\n:tada: Doubles: {}\n:thinking: Win-rate: {}%{}{}**".format(user_mention, stats[0], stats[1], win_rate, memes, tokens)
await client.send_message(message.channel, letter)
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
MenuPage.__init__(self, parent, controller)
buttonWidth = mfloor((windowWidth / 7) / 7.5)
tk.Label(self,
text="Menu",
font=controller.title_font,
bg=controller.bgCol).grid(sticky="W",
row=1,
column=1,
columnspan=7,
padx=10)
#tk.Button(self, text="Save", command=lambda: controller.save_game('sav1'), width = buttonWidth, bg=color0hex).grid(row=3, column=4)
tk.Button(self,
text="Load",
command=lambda: controller.load_game("EscPage"),
width=buttonWidth,
bg=color0hex).grid(row=4, column=4)
tk.Button(self,
text="Options",
command=lambda: controller.show_frame("EscPage"),
width=buttonWidth,
bg=color0hex).grid(row=5, column=4)
tk.Button(self,
text="Exit to main menu",
command=lambda: controller.show_frame("MenuMenu"),
width=buttonWidth,
bg=color0hex).grid(row=6, column=4)
tk.Button(self,
text="Exit to OS",
command=lambda: sys.exit(),
width=buttonWidth,
bg=color0hex).grid(row=7, column=4)
def total_weeks(offset=3):
# Calculating time from epoch
epoch_start = datetime.utcfromtimestamp(0)
now = datetime.today()
delta = now - epoch_start
# calculating week with offset and returning it
week_amount = mfloor((delta.days + offset) / 7)
return week_amount
async def main(self, bot, database, message, arguments):
if len(arguments) == 0:
owner = message.author
else:
owner = await bot.utils.get_user_instance(message.server,
arguments[0])
stats = bot.database.double.get_stats_user(owner.id)
if stats is None:
return
name = bot.utils.author_nickanme(owner)
user_mention = " for: " + name
# Calculating winrate
try:
win_rate = mfloor(int(stats.doubles) / int(stats.rows) * 100)
except:
win_rate = "0"
if stats.memes == 0:
memes = ""
else:
try:
memes = "\n:money_with_wings: Memes gained: {}".format(
mfloor(stats.memes))
except:
memes = ""
if stats.tokens == 0:
tokens = ""
else:
try:
tokens = "\n:trophy: Tokens gained: {}".format(
mfloor(stats.tokens))
except:
tokens = ""
letter = ":game_die: **| Roll stats{}\n\n:arrows_counterclockwise: Rolled: {}\n:tada: Doubles: {}\n:thinking: Win-rate: {}%{}{}**".format(
user_mention, stats.rows, stats.doubles, win_rate, memes, tokens)
await bot.say(message.channel, letter)
async def online(message, client, arguments):
cooldown_lists_time = global_cd_list_per_command()
asd = cooldown_lists_time.bot_start_up_time
# Calc time
time_now = datetime.now()
#asd = bot_start_up_time()
time_in_seconds = mfloor((time_now - asd).total_seconds())
#time
if time_in_seconds < 60:
asd = str(time_in_seconds) + " seconds"
elif time_in_seconds < 3600:
asd = str(mfloor(time_in_seconds / 60)) + " minutes"
elif time_in_seconds < 86400:
asd = str(mfloor(time_in_seconds / 3600)) + " hours"
elif time_in_seconds < 604800:
asd = str(mfloor(time_in_seconds / 86400)) + " days"
elif time_in_seconds < 2419200:
asd = str(mfloor(time_in_seconds / 604800)) + " weeks"
elif time_in_seconds >= 2419200:
asd = str(mfloor(time_in_seconds / 2419200)) + " months"
# sending message ///UNDER CONSTRUCTION
asdaa = server_stats_restarts()
await client.send_message(
message.channel, ":clock10: **| bot has been online for " + asd +
" and has been restarted " + asdaa + " times**")
async def main(self, bot, database, message, arguments):
if not arguments:
letter = ":clock11: **| Servers time is {}**".format(
str(datetime.fromtimestamp(mfloor(time())).strftime('%H:%M')))
await bot.say(message.channel, letter)
else:
google = quote(str(arguments[0]))
query = "https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}&language={}".format(
google, bot.config.google.key, "en")
json_data = await bot.utils.web.get_content(query)
geo = bot.utils.json2obj(json_data)
if geo.status == "OK":
lat = str(
float("{0:.4f}".format(
geo.results[0].geometry.location.lat)))
lng = str(
float("{0:.4f}".format(
geo.results[0].geometry.location.lng)))
query = "https://maps.googleapis.com/maps/api/timezone/json?location=%s,%s×tamp=%s&key=%s&language=%s" % (
lat, lng, time(), bot.config.google.key, "en")
json_data = await bot.utils.web.get_content(query)
location = bot.utils.json2obj(json_data)
time_now = str(
int(time() + location.rawOffset + location.dstOffset))
time_in_hour_format = datetime.fromtimestamp(
int(time_now)).strftime('%H:%M')
time_in_weekday = datetime.fromtimestamp(
int(time_now)).weekday()
if time_in_weekday == 0: day_is = "Monday"
elif time_in_weekday == 1: day_is = "Tuesday"
elif time_in_weekday == 2: day_is = "Wednesday"
elif time_in_weekday == 3: day_is = "Thursday"
elif time_in_weekday == 4: day_is = "Friday"
elif time_in_weekday == 5: day_is = "Saturday"
elif time_in_weekday == 6: day_is = "Sunday"
letter = ":clock11: **| Time in {} is {} and the day is {}**".format(
geo.results[0].formatted_address, time_in_hour_format,
day_is)
await bot.say(message.channel, letter)
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
buttonWidth = mfloor((windowWidth / 7) / 7.5)
tk.Button(self,
text="Stats",
command=lambda: controller.show_frame("StatsPage"),
width=buttonWidth,
bg=color0hex,
fg=color1hex).grid(row=0, column=1, pady=10)
tk.Button(self,
text="Drivers",
command=lambda: controller.show_frame("DriversPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=2)
tk.Button(self,
text="Cars",
command=lambda: controller.show_frame("CarPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=3)
tk.Button(self,
text="Money",
command=lambda: controller.show_frame("MoneyPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=4)
tk.Button(self,
text="Ranks",
command=lambda: controller.show_frame("RanksPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=5)
tk.Button(self,
text="Wiki",
command=lambda: controller.show_frame("WikiPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=6)
tk.Button(self,
text="Menu",
command=lambda: controller.show_frame("EscPage"),
width=buttonWidth,
bg=color0hex).grid(row=0, column=7)
Frame(self, bg=color2hex, height=5, width=windowWidth).grid(
row=2, column=1,
columnspan=7) #linia przerwy między menu, a resztą strony
Frame(self, bg=color2hex, height=5, width=windowWidth).grid(
row=10, column=1, columnspan=7
) #linia przerwy między resztą strony, a paskiem czasu, przyciski na górze
def analyse(self):
# Note: This algorithm was tested with data acquired at BM29 in late 2012, early 2013
# Changes in the acquisition protocol might require adaption of parameters
# paramterers for finding ROIs:
smoothing_degree = 9
# parameters for smoothing for peak finding
nyf = 0.5
first_butter_par = 4
second_butter_par = 0.1 / nyf
# parameters for peak finding algorithm
window_min_size = 1
window_max_size_rel = 0.2 # to be multiplied by size of ROI
Ismooth = medfilt(self.I0, smoothing_degree)
lab = label(Ismooth)
Rgsmooth = medfilt(self.Rg, smoothing_degree)
res = []
self.merge_frames = []
for i in range(1, int(lab.max() + 1)):
loc = (lab == i)
c = loc.sum()
# Only analyse peak regions of at leat 10 subsequent frames
if c > 10:
idx = numpy.where(loc)[0]
start = idx[0]
stop = idx[-1]
Ishort = self.I0[start:stop]
I0med = Ismooth[start:stop]
Rgmed = Rgsmooth[start:stop]
Rg_Stdshort = self.Rg_Stdev[start:stop]
Rgshort = self.Rg[start:stop]
# This is an attempt to remove "dirt" - long broad peaks with no real peeak structure, noise on short timescales
# Test this with Ishort vs I0med
if datasmoothness(Ishort, I0med) < 0.25:
#
# we smooth the data with a butterworth filter to remove high-frequency noise
b, a = butter(first_butter_par, second_butter_par)
fl = filtfilt(b, a, Ishort)
# The parameters for the peak finding
window_max_size = mfloor(window_max_size_rel *
len(numpy.where(fl)[0]))
peaks = find_peaks_cwt(
fl, numpy.arange(window_min_size, window_max_size))
for i in range(len(peaks)):
peak = peaks[i]
if peaks[i - 1] < peak:
minindex = (peaks[i - 1] + peak) / 2
else:
minindex = 0
if i < len(peaks) - 1:
maxindex = (peaks[i + 1] + peak) / 2
else:
maxindex = stop - start - 1
if peak < maxindex and len(I0med[peak:maxindex]) > 1:
maxindex = I0med[peak:maxindex].argmin() + peak
if minindex < peak and len(
I0med[minindex:peak + 1]) > 1:
minindex = I0med[minindex:peak +
1].argmin() + minindex
maxi = I0med[minindex:maxindex].argmax() + minindex
if datasmoothness(Ishort[minindex:maxindex],
I0med[minindex:maxindex]) < 0.3:
if I0med[peak] >= I0med[maxindex] and I0med[
peak] >= I0med[
minindex] and maxindex - minindex > 10:
rg0 = Rgmed[maxi]
srg0 = Rg_Stdshort[maxi]
good = ((abs(Rgmed - rg0) < srg0))
good[maxindex] = False
if not (len(
numpy.where(
good[minindex:maxi] == False)[0])
== 0):
regionstart = numpy.where(
good[minindex:maxi] ==
False)[0].max() + minindex
else:
regionstart = minindex
if not (len(
numpy.where(
good[maxi:maxindex] == False)[0])
== 0):
regionend = numpy.where(
good[maxi:maxindex] ==
False)[0].min() + maxi
else:
regionend = maxindex
if regionend - regionstart > 5:
good[:regionstart] = 0
good[regionend:] = 0
lg = label(good)
lv = lg[maxi]
region = numpy.where(lg == lv)[0] + start
res.append(region)
self.merge_frames.append(
[region[0], region[-1]])
return res
import tkinter as tk
from tkinter import *
from tkinter import ttk
from tkinter import font as tkfont
from tkinter import messagebox
from math import floor as mfloor
from faker import Faker
from PIL import Image, ImageDraw
import pickle
from colour import Color
import colorsys
import random
saveName = 'sav1'
windowWidth = 800
windowHeight = 400
buttonWidth = mfloor((windowWidth / 7) / 7.5)
with open('sav1', 'rb') as f:
data = pickle.load(f)
color0 = data['playercolors'][0]
color1 = data['playercolors'][1]
color2 = data['playercolors'][2]
color0hex = '#%02x%02x%02x' % color0
color1hex = '#%02x%02x%02x' % color1
color2hex = '#%02x%02x%02x' % color2
class SampleApp(tk.Tk):
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
self.title_font = tkfont.Font(family='Lato',
size=18,
async def time_new(message, client, arguments):
if not arguments:
letter = ":clock11: **| Servers time is " + str(
datetime.fromtimestamp(mfloor(time())).strftime('%H:%M')) + "**"
await client.send_message(message.channel, letter)
return
else:
google = quote(str(arguments))
query = "https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}&language={}".format(
google, google_api_key, "en")
response = loads(rget(query).text)
if response["status"] == "OK":
# getting lat and lng
lat = str(
float("{0:.4f}".format(
response["results"][0]["geometry"]["location"]["lat"])))
lng = str(
float("{0:.4f}".format(
response["results"][0]["geometry"]["location"]["lng"])))
# Getting time by place
query = "https://maps.googleapis.com/maps/api/timezone/json?location=%s,%s×tamp=%s&key=%s&language=%s" % (
lat, lng, time(), google_api_key, "en")
time_in_location = loads(rget(query).text)
# Calculating time
time_now = str(
int(time() + time_in_location["rawOffset"] +
time_in_location["dstOffset"]))
time_in_hour_format = datetime.fromtimestamp(
int(time_now)).strftime('%H:%M')
time_in_weekday = datetime.fromtimestamp(int(time_now)).weekday()
# Setting weekday
if time_in_weekday == 0:
day_is = "Monday"
elif time_in_weekday == 1:
day_is = "Tuesday"
elif time_in_weekday == 2:
day_is = "Wednesday"
elif time_in_weekday == 3:
day_is = "Thursday"
elif time_in_weekday == 4:
day_is = "Friday"
elif time_in_weekday == 5:
day_is = "Saturday"
elif time_in_weekday == 6:
day_is = "Sunday"
# Sending message
adsasdadsfdas = ":clock11: **| Time in {} is {} and the day is {}**".format(
str(response["results"][0]["formatted_address"]),
time_in_hour_format, day_is)
await client.send_message(message.channel, adsasdadsfdas)
return
send(1, "Time done!")
def analyse(self):
# Note: This algorithm was tested with data acquired at BM29 in late 2012, early 2013
# Changes in the acquisition protocol might require adaption of parameters
# paramterers for finding ROIs:
smoothing_degree = 9
# parameters for smoothing for peak finding
nyf = 0.5
first_butter_par = 4
second_butter_par = 0.1 / nyf
# parameters for peak finding algorithm
window_min_size = 1
window_max_size_rel = 0.2 # to be multiplied by size of ROI
Ismooth = medfilt(self.I0, smoothing_degree)
lab = label(Ismooth)
Rgsmooth = medfilt(self.Rg, smoothing_degree)
res = []
self.merge_frames = []
for i in range(1, int(lab.max() + 1)):
loc = (lab == i)
c = loc.sum()
# Only analyse peak regions of at leat 10 subsequent frames
if c > 10:
idx = numpy.where(loc)[0]
start = idx[0]
stop = idx[-1]
Ishort = self.I0[start:stop]
I0med = Ismooth[start:stop]
Rgmed = Rgsmooth[start:stop]
Rg_Stdshort = self.Rg_Stdev[start:stop]
# Rgshort = self.Rg[start:stop]
# This is an attempt to remove "dirt" - long broad peaks with no real peeak structure, noise on short timescales
# Test this with Ishort vs I0med
if datasmoothness(Ishort, I0med) < 0.25:
# we smooth the data with a butterworth filter to remove high-frequency noise
b, a = butter(first_butter_par, second_butter_par)
# We should take care of the pading length to avoid errors
if 3 * max(len(a), len(b)) > len(Ishort):
fl = filtfilt(b, a, Ishort)
else:
fl = filtfilt(b, a, Ishort, padlen=Ishort.shape[0] - 2)
# The parameters for the peak finding
window_max_size = mfloor(window_max_size_rel * len(numpy.where(fl)[0]))
peaks = find_peaks_cwt(fl, numpy.arange(window_min_size, window_max_size))
for i in range(len(peaks)):
peak = peaks[i]
if peaks[i - 1] < peak:
minindex = (peaks[i - 1] + peak) / 2
else:
minindex = 0
if i < len(peaks) - 1:
maxindex = (peaks[i + 1] + peak) / 2
else:
maxindex = stop - start - 1
if peak < maxindex and len(I0med[peak:maxindex]) > 1:
maxindex = I0med[peak:maxindex].argmin() + peak
if (minindex < peak) and (len(I0med[minindex:peak + 1]) > 1):
minindex = I0med[minindex:peak + 1].argmin() + minindex
maxi = I0med[minindex:maxindex].argmax() + minindex
if datasmoothness(Ishort[minindex:maxindex], I0med[minindex:maxindex]) < 0.3:
if I0med[peak] >= I0med[maxindex] and I0med[peak] >= I0med[minindex] and maxindex - minindex > 10:
rg0 = Rgmed[maxi]
srg0 = max(Rg_Stdshort[maxi], 0.1) # The error estimate for a single frame can be unreallistically small
good = ((abs(Rgmed - rg0) < srg0))
good[maxindex] = False
if not (len(numpy.where(good[minindex:maxi] == False)[0]) == 0):
regionstart = numpy.where(good[minindex:maxi] == False)[0].max() + minindex
else:
regionstart = minindex
if not (len(numpy.where(good[maxi:maxindex] == False)[0]) == 0):
regionend = numpy.where(good[maxi:maxindex] == False)[0].min() + maxi
else:
regionend = maxindex
if regionend - regionstart > 5:
good[:regionstart] = 0
good[regionend:] = 0
lg = label(good)
lv = lg[maxi]
region = numpy.where(lg == lv)[0] + start
res.append(region)
self.merge_frames.append([region[0], region[-1]])
return res
async def roulette(message, client, arguments):
# Catching errors so you won't get tiemd out forever
if 1:
#try:
#if not message.channel.id in ["404356322595962880"]:
# return
if len(arguments) == 1:
#VALUES
min_points = ROULETTE_MIN_POINTS
winrate = ROULETTE_WINRATE
special_winrate = ROULETTE_SPECIAL_WINRATE
rand_low = ROULETTE_RAND_LOW
rand_high = ROULETTE_RAND_HIGH
special_channels = ROULETTE_SPECIAL_CHANNELS
# Variables
multiplier_outcome_str = "" # DO NOT TOUCH
multiplier_outcome_multiplier_str = "" # DO NOT TOUCH
amount = arguments[0] # DO NOT TOUCH
# Getting name
try:
name = message.author.nick
if name is None:
name = message.author.name
except:
name = message.author.name
# Getting the amount of points
user_points = users_get_daily_points(message.author.id)[0]
#Validating input and roulette amount
if amount != "all":
# all in
all_in = False
# Checking for k=1000 points
if "k" in amount:
amount = float(arguments[0].lower().replace("k","")) * 1000
#Checking if number
try:
user_gamble = int(amount)
except ValueError:
return
# Assigning users all points for !roulette all
else:
user_gamble = user_points
all_in = True
# Checking if user gambled mreo than x aoumnt of points
if user_gamble < min_points:
await client.send_message(message.channel, "<@{}> **You have to gamble at least {} memes!**".format(message.author.id, min_points))
return
# Checking pointsif user_gamble > user_points :
if user_gamble > user_points:
await client.send_message(message.channel, "<@{}> **You don't have enough memes to gamble, you need {} memes!**".format(message.author.id, user_gamble - user_points))
return
# Cpecial channels
if message.channel.id in special_channels:
if randint(1,100) > special_winrate:
winrate = special_winrate
# Creating multiplier and some other stuff
mvalue = float(randint(rand_low, rand_high) / 100)
moutcome = int(mfloor(user_gamble * mvalue - user_gamble))
multiplier_outcome_str = "**+" + str(moutcome) + "**"
multiplier_outcome_multiplier_str = "Multiplier " + str(mvalue)
info3 = str(mvalue)
else:
info3 = ""
else:
info3 = ""
info1 = ""
info2 = ""
# Win
if randint(1,100) < winrate:
# Calculations for message formation later on
outcome_total = user_gamble # + multiplier TODO
total_points = user_points + outcome_total
# Adding points and logging event for user
users_set_points_to_plus(user_gamble, message.author.id)
#points_history_roulette_add(message.author.id, "", user_gamble, "win", all_in)
# Determine afterfix
if all_in:
win_afterfix = ":confetti_ball: :confetti_ball:"
info2 = "All in"
else:
win_afterfix = ":confetti_ball:"
# Creating message
letter = "** :slot_machine: | {}, you have won {}{} memes, you now have {} memes! {} {}** ".format(name, outcome_total, multiplier_outcome_str, total_points, win_afterfix, multiplier_outcome_multiplier_str)
try:
win_str_plus = "+" + str(int(outcome_total)+int(moutcome))
plus = int(outcome_total)+int(moutcome)
except:
win_str_plus = "+" + str(int(outcome_total))
plus = int(outcome_total)
minus = 0
info1 = "Win"
# Lose
else:
info3 = ""
# Calculations for message formation later on
outcome_total = user_gamble # + multiplier disabled cause not fair LUL
total_points = user_points - outcome_total
# Adding points and logging event for user
users_set_points_to_minus(user_gamble, message.author.id)
#points_history_roulette_add(message.author.id, "", user_gamble, "lose", all_in)
# Determine afterfix
if all_in:
win_afterfix = "<:angery:280761870447673344>"
info2 = "All in"
else:
win_afterfix = "<:feelsrageman:318490463323553795>"
# Creating message
letter = "** :slot_machine: | {}, you have lost {} memes, you now have {} memes! {}** ".format(name, outcome_total, total_points, win_afterfix)
win_str_plus = "-" + str(user_gamble)
plus = 0
minus = int(user_gamble)
info1 = "Lose"
points_stats_insert(message.server.id, message.author.id, 5, "Roulette", str(user_gamble), "", win_str_plus, "", info1, info2, info3, "", 0, plus, minus)
# Sending message, checking if worth of excitement
if user_gamble / user_points > 0.8:
# TODO add expression system to config file
msg = await client.send_message(message.channel, "**<:VenskerChamp:313049600984612865> Rolling **")
await sleepS(4.0)
await client.edit_message(msg, letter)
return
# if not high bet do this no excitement
else:
await client.send_message(message.channel, letter)
def _floor(x):
return int(mfloor(x))
async def main(self, bot, database, message, arguments):
user = bot.database.user.get(message.author.id).points
#!? give all points
if arguments[1] == "all":
arguments[1] == user
try:
amount = int(arguments[1])
except ValueError:
await bot.say(message.channel, "Invalid amount")
return
if user < amount:
await bot.say(message.channel, "You don't have enough memes!")
return
# less than 10
if amount < 10:
await bot.say(message.channel, "transfer at least 10 memes!")
return
# Transferring to user instance
user_getting = await bot.utils.get_user_instance(
message.server, arguments[0])
if user_getting is None:
await bot.say(message.channel, "can't find user")
return
# checking if sending money toself
if user_getting == message.author:
await bot.say(message.channel, "Can't send money to yourself!")
return
letter = ":no_entry:** Olet siirtämässä __{}__ meemiä käyttäjälle {}!**\n\nTAX: **{}:money_with_wings: - 20% => {}:money_with_wings:**\nSinun meemisi: **{}:money_with_wings: -> {}:money_with_wings:**\n\n **Hyväksy** seuraavan 20 sekunnin aikana **kirjoittamalla: __PENIS__**".format(
amount, user_getting.name, amount, mfloor(int(amount) * 80 / 100),
user, str(int(user) - int(amount)))
keepo = await bot.say(message.channel, letter)
# Waiting for right response from user
guess = await bot.wait_for_message(timeout=20.0,
author=message.author,
check=self.guess_check)
# After time passes
if guess is None:
letter = ":no_entry_sign: **| Transaction cancelled!**"
await bot.edit_message(keepo, letter)
# After confirmed
elif guess.content == "PENIS":
# adding and removing points SOME NASTY MATH
bot.database.user.points_alter(message.author.id, -amount)
bot.database.user.points_alter(user_getting.id, amount)
bot.database.server.tax_pot_alter(
message.server.id, int(mfloor(int(amount) * 20 / 100)))
# Sending message
await bot.delete_message(keepo)
await bot.say(message.channel,
":white_check_mark: **| Siirto onnistui!**")
bot.database.pointhistory.add(message.author.id, message.server.id,
7, "Transfer", False, amount, "",
"-" + str(amount), "",
user_getting.name, "", "", "", 0, 0,
int(amount))
bot.database.pointhistory.add(user_getting.id, message.server.id,
7, "Transfer", False, "", "",
"+" + str(amount), "",
message.author.name, "", "", "", 0,
int(amount), 0)
