def getlocalscores(self, mods):
try:
scores = getscores(self.beatmaphash,
os.path.join(self.settings.osu, "scores.db"))
except Exception as e:
logger.error("from scoreboard: %s", repr(e))
return
for i in range(len(scores["scores"])):
score = scores["scores"][i]
if int(
score["score"]
) == self.playerscore and score["player"] == self.playername:
continue
summods = getsummods(mods)
if summods != score["mods"]["modFlags"] and summods != "*":
continue
strscore = re.sub(r'(?<!^)(?=(\d{3})+$)', r'.',
str(score["score"])) # add dot to every 3 digits
strcombo = re.sub(r'(?<!^)(?=(\d{3})+$)', r'.',
str(score["max_combo"]))
self.scoreboards.append(
BoardInfo(strscore, strcombo, score["score"],
score["max_combo"], score["player"], None, None,
None, i))
self.oldrankid = None
def getmapid(self, meta, maphash):
if "BeatmapID" in meta:
return meta["BeatmapID"]
if not self.settings.settings["Global leaderboard"]:
return -1
k = self.settings.settings["api key"]
if k is None:
logger.error(
"\n\n YOU DID NOT ENTERED THE API KEY. GET THE API HERE https://osu.ppy.sh/p/api/\n\n"
)
return
data = {'k': k, 'h': maphash}
r = requests.post("https://osu.ppy.sh/api/get_beatmaps", data=data)
try:
data = json.loads(r.text)
except json.decoder.JSONDecodeError:
return
if type(data).__name__ == "list":
if len(data) == 0:
return
return data[0].get("beatmap_id", -1)
return data.get("beatmap_id", -1)
def getaudiofromfile(filename,
path,
defaultpath,
settings,
volume=1.0,
speed=1.0):
fmts = ["wav", "mp3", "ogg"]
for fmt in fmts:
try:
return read(os.path.join(path, filename + "." + fmt),
settings,
volume=volume,
speed=speed)
except FileNotFoundError:
pass
except exceptions.CouldntDecodeError as e:
logger.error(
repr(e) + " filename " +
os.path.join(path, filename + "." + fmt))
return 1, np.zeros((0, 2), dtype=np.float32)
logger.warning("file not found %s, using default skin", filename)
if defaultpath is not None:
return getaudiofromfile(filename,
defaultpath,
None,
settings,
volume=volume,
speed=speed)
logger.error("file not found %s", filename)
return 1, np.zeros((0, 2), dtype=np.float32)
def parse_timingpoints(self):
timing = self.info["TimingPoints"]
timing = timing.split("\n")
inherited = 0
for line in timing:
my_dict = {}
try:
line = line.strip()
if line == '':
continue
items = line.split(",")
my_dict["Offset"] = float(items[0])
if len(items) < 7 or int(items[6]) == 1:
my_dict["BeatDuration"] = float(items[1])
inherited = my_dict["BeatDuration"]
else:
my_dict["BeatDuration"] = max(
10.0, min(1000.0, -float(items[1]))) * inherited / 100
my_dict["Base"] = inherited
my_dict["Meter"] = int(items[2])
my_dict["SampleSet"] = items[3]
my_dict["SampleIndex"] = items[4]
my_dict["Volume"] = float(items[5])
except Exception as e:
my_dict["Meter"] = my_dict.get("Meter", 0)
my_dict["SampleSet"] = my_dict.get("SampleSet", "0")
my_dict["SampleIndex"] = my_dict.get("SampleIndex", "0")
my_dict["Volume"] = my_dict.get("Volume", 100)
self.timing_point.append(my_dict)
logger.error(repr(e))
continue
# my_dict["Kiai"] = int(items[7])
self.timing_point.append(my_dict)
self.timing_point.append({"Offset": float('inf')})
self.timing_point.append({"Offset": float('inf')})
def parseString(db, offset):
existence = unpack_from('b', db, offset)[0]
if existence == 0x00:
return ("", offset + 1)
elif existence == 0x0b:
# decode ULEB128
length = 0
shift = 0
offset += 1
while True:
val = unpack_from('B', db, offset)[0]
length |= ((val & 0x7F) << shift)
offset += 1
if (val & (1 << 7)) == 0:
break
shift += 7
string = unpack_from(str(length) + 's', db, offset)[0]
offset += length
unic = u''
try:
unic = str(string, 'utf-8')
except UnicodeDecodeError:
logger.error("Could not parse UTF-8 string, returning empty string.")
return (unic, offset)
def loadimg(self):
char = [str(x) for x in range(10)]
char.append(".")
char.append(" ")
frames = prepare_text(
char,
self.countersettings[self.prefix + "Size"] * self.settings.scale,
self.countersettings[self.prefix + "Rgb"],
self.settings,
alpha=self.countersettings[self.prefix + "Alpha"],
fontpath=self.countersettings[self.prefix + "Font"])
for i in frames:
self.frames[int(i) if i.isdigit() else i] = frames[i]
try:
self.background = Image.open(
self.countersettings[self.prefix +
"Background"]).convert("RGBA")
scale = self.settings.scale * self.countersettings[self.prefix +
"Size"] / 20
self.background = imageproc.change_size(self.background, scale,
scale)
except Exception as e:
logger.error(repr(e))
self.background = Image.new("RGBA", (1, 1))
def write_frame(shared, conn, filename, settings, iii):
try:
write(shared, conn, filename, settings, iii)
except Exception as e:
tb = traceback.format_exc()
with open("error.txt", "w") as fwrite: # temporary fix
fwrite.write(repr(e))
logger.error("{} from {}\n{}\n\n\n".format(tb, filename, repr(e)))
raise
def processaudio(my_info, beatmap, offset, endtime, mods, settings):
try:
audioprc(my_info, beatmap, offset, endtime, mods, settings)
except Exception as e:
error = repr(e)
with open("error.txt", "w") as fwrite: # temporary fix
fwrite.write(repr(e))
logger.error("{} from audio\n\n\n".format(error))
raise
def draw_frame(shared, conn, beatmap, replay_info, resultinfo, videotime,
settings, showranking):
try:
draw(shared, conn, beatmap, replay_info, resultinfo, videotime,
settings, showranking)
except Exception as e:
tb = traceback.format_exc()
with open("error.txt", "w") as fwrite: # temporary fix
fwrite.write(repr(e))
logger.error("{} from {}\n{}\n\n\n".format(tb, videotime, repr(e)))
raise
def getglobalscores(self, mods):
k = self.settings.settings["api key"]
if k is None:
logger.error(
"\n\n YOU DID NOT ENTERED THE API KEY. GET THE API HERE https://osu.ppy.sh/p/api/\n\n"
)
self.getlocalscores(mods)
return
if mods == "*":
data = {'k': k, 'b': self.beatmapid}
else:
summods = getsummods(mods)
data = {'k': k, 'b': self.beatmapid, 'mods': summods}
r = requests.post("https://osu.ppy.sh/api/get_scores", data=data)
try:
data = json.loads(r.text)
except json.decoder.JSONDecodeError:
return
if "error" in data:
logger.error("\n\n {} \n\n".format(data["error"]))
self.getlocalscores(mods)
return
for i in range(len(data)):
score = data[i]
if score["username"] == self.playername:
if int(score["score"]) == self.playerscore:
self.removeone = 1
continue
if len(score["username"]) > 13:
score["username"] = score["username"][:13] + ".."
keepgoing = self.filter(score["user_id"], int(score["score"]))
if not keepgoing:
continue
strscore = re.sub(r'(?<!^)(?=(\d{3})+$)', r'.',
str(score["score"])) # add dot to every 3 digits
strcombo = re.sub(r'(?<!^)(?=(\d{3})+$)', r'.',
str(score["maxcombo"]))
self.scoreboards.append(
BoardInfo(strscore, strcombo, int(score["score"]),
int(score["maxcombo"]), score["username"], None,
None, None, i))
self.oldrankid = None
def cleanup(self):
try:
if self.drawers is not None:
for x in range(len(self.drawers)):
self.drawers[x].terminate()
self.writers[x].terminate()
conn1, conn2 = self.pipes[x]
conn1.close()
conn2.close()
if self.audio is not None:
self.audio.terminate()
except Exception as e:
logger.error(repr(e))
cleanup(self.settings)
def pydubtonumpy(audiosegment):
y = np.array(audiosegment.get_array_of_samples())
if audiosegment.channels == 2:
y = y.reshape((-1, 2))
if audiosegment.channels == 1:
y1 = np.zeros((len(y), 2), dtype=y.dtype)
y1[:, 0] = y * 0.5
y1[:, 1] = y * 0.5
y = y1
try:
h = max(2, audiosegment.sample_width) * 8
maxvalue = max(np.amax(y), 2**h)
except ValueError as e:
logger.error(repr(e))
maxvalue = 1
return audiosegment.frame_rate, np.float64(y) / maxvalue
def parse_timingpoints(self):
timings = self.info["TimingPoints"].split("\n")
inherited = 0
for line in timings:
timing = {}
try:
line = line.strip()
if not line:
continue
items = line.split(",")
timing["Offset"] = float(items[0])
if len(items) < 7 or int(items[6]) == 1:
timing["BeatDuration"] = float(items[1])
inherited = timing["BeatDuration"]
else:
timing["BeatDuration"] = max(
10.0, min(1000.0, -float(items[1]))) * inherited / 100
timing["Base"] = inherited
timing["Meter"] = int(items[2])
timing["SampleSet"] = items[3]
timing["SampleIndex"] = items[4]
timing["Volume"] = float(items[5])
except Exception as e:
timing["Meter"] = timing.get("Meter", 0)
timing["SampleSet"] = timing.get("SampleSet", "0")
timing["SampleIndex"] = timing.get("SampleIndex", "0")
timing["Volume"] = timing.get("Volume", 100)
self.timing_point.append(timing)
logger.error(repr(e))
continue
# my_dict["Kiai"] = int(items[7])
self.timing_point.append(timing)
self.timing_point.append({"Offset": float('inf')})
self.timing_point.append({"Offset":
float('inf')}) # FireRedz: mega sus
def prepare_text(texts, size, color, settings, alpha=1, fontpath=""):
if fontpath == "":
fontpath = os.path.join(settings.path, "res/Aller_Rg.ttf")
size = int(size)
try:
font = ImageFont.truetype(fontpath, size=size)
except Exception as e:
font = ImageFont.truetype(os.path.join(settings.path,
"res/Aller_Rg.ttf"),
size=size)
logger.error(repr(e))
img = Image.new("RGBA", (settings.width, settings.height))
imgdraw = ImageDraw.Draw(img)
imgs = {}
for text in texts:
img.paste((0, 0, 0, 0), (0, 0, img.size[0], img.size[1]))
s = imgdraw.textsize(text, font=font)
imgdraw.text((0, 0), text, color, font=font, spacing=size)
imgs[text] = imageproc.newalpha(img.crop((0, 0, s[0], s[1])), alpha)
return imgs
def prepare_background(backgroundname, settings):
"""
:param backgroundname: string
:return: PIL.Image
"""
try:
img = Image.open(backgroundname).convert("RGBA")
except Exception as e:
logger.error(repr(e))
img = Image.open(os.path.join(settings.path,
"res/bg.png")).convert("RGBA")
width = settings.width
height = settings.height
ratiow = width / height
ratioh = height / width
w = min(img.size[0], int(img.size[1] * ratiow))
h = min(img.size[1], int(img.size[0] * ratioh))
x, y = (img.size[0] - w) // 2, (img.size[1] - h) // 2
img = img.crop((x, y, x + w, y + h))
scale = width / w
img = imageproc.change_size(img, scale, scale)
imgs = [Image.new("RGBA", (1, 1))]
dim = max(0, min(100, (100 - settings.settings["Background dim"]))) * 2.55
color = np.array([dim, dim, dim])
interval = int(1000 / 45)
c_interval = max(0, (settings.settings["Background dim"] - 50) * 2.55 /
interval)
color[:] = color[:] - c_interval
for x in range(interval):
color[:] = color[:] + c_interval
a = imageproc.add_color(img, color)
imgs.append(a)
return imgs
