def prepare_particles(scale, settings):
frames = {}
for hit in [50, 100]:
yimg = YImage(particleprefix + str(hit), settings, scale)
yimg2 = YImage(hitprefix + str(hit), settings, scale)
if yimg.imgfrom == ImageFrom.DEFAULT_X or yimg.imgfrom == ImageFrom.DEFAULT_X2 or yimg.imgfrom == ImageFrom.BLANK:
continue
fr = []
sizee = int(200 * scale)
f = [[sizee / 2, sizee / 2, 100] for i in range(100)]
for z in range(120):
background = Image.new("RGBA", (sizee, sizee), (0, 0, 0, 0))
for b in range(len(f)):
pos = f[b]
x, y = pseudorandom(b)
pos[0] += x * scale
pos[1] += y * scale
pos[2] -= max(1, (abs(x) + abs(y)) * 1.25)
imageproc.add(yimg.img,
background,
pos[0],
pos[1],
alpha=max(0.0, min(1.0, pos[2] / 100)),
channel=4)
imageproc.add(yimg2.img, background, 60, 60)
if z > 3:
fr.append(background)
# background.save(f"test{z}.png")
frames[hit] = fr
return frames
def load(scale, settings):
arrow_frames = []
for x in range(120, 100, -4):
img = YImage(reversearrow, settings, scale * x / 100, rotate=1)
arrow_frames.append(img.img)
sliderb_frames = YImages(sliderb, settings, scale).frames
sliderfollow_frames = YImages(sliderfollowcircle, settings, scale).frames
slider_tick = YImage(sliderscorepoint, settings, scale).img
return arrow_frames, sliderb_frames, sliderfollow_frames, slider_tick
def prepare_sections(scale, settings):
"""
:param settings:
:param scale: float
:return: [PIL.Image]
"""
spass = YImage(section_pass, settings, scale).img
sfail = YImage(section_fail, settings, scale).img
frame = [sfail, spass]
return frame
def load(settings):
circle = YImage(hitcircle, settings).img
c_overlay = YImages(hitcircleoverlay, settings, delimiter="-").frames[0]
yslider = YImage(sliderstartcircle, settings, fallback=hitcircle)
slider = yslider.img
slideroverlay = sliderstartcircleoverlay
if yslider.imgfrom == ImageFrom.FALLBACK_X or yslider.imgfrom == ImageFrom.FALLBACK_X2:
slideroverlay = hitcircleoverlay
s_overlay = YImage(slideroverlay, settings, fallback=hitcircleoverlay).img
return circle, c_overlay, slider, s_overlay
def prepare_arrowwarning(scale, settings):
"""
:param settings:
:param scale: float
:return: [PIL.Image]
"""
yimg = YImage(arrowwarning, settings, scale)
if yimg.imgfrom == ImageFrom.BLANK:
yimg = YImage(playwarningarrow, settings, scale)
img = yimg.img
img2 = img.transpose(Image.FLIP_LEFT_RIGHT)
return [img, img2]
def prepare_scoreboard(scale, settings): """ :param scale: float :return: [PIL.Image] """ img = YImage(scoreboard, settings, scale).img img = img.crop((int(img.size[0] * 2/3), 0, img.size[0], img.size[1])) img = img.resize((int(140 * scale), int(64 * scale))) imageproc.changealpha(img, 0.3) playerimg = imageproc.add_color(img, [80, 80, 80]) img = imageproc.add_color(img, [60, 70, 120]) return [img, playerimg]
def prepare_rankinggrade(scale, settings):
frames = []
grades = ["X", "S", "A", "B", "C", "D"]
for grade in grades:
frames.append(YImage(ranking + grade, settings, scale).img)
frameshd = [
YImage(ranking + "XH", settings, scale).img,
YImage(ranking + "SH", settings, scale).img
]
frameshd.extend(frames[2:])
return frames, frameshd
def prepare_modicons(scale, settings):
modnames = {
Mod.Autoplay: "autoplay",
Mod.Perfect: "perfect",
Mod.Autopilot: "pilot",
Mod.Relax: "relax",
Mod.SpunOut: "spunout",
Mod.Flashlight: "flashlight",
Mod.Hidden: "hidden",
Mod.Nightcore: "nightcore",
Mod.DoubleTime: "doubletime",
Mod.SuddenDeath: "suddendeath",
Mod.HardRock: "hardrock",
Mod.HardSoft: "hardrock",
Mod.HalfTime: "halftime",
Mod.NoFail: "nofail",
Mod.Easy: "easy",
}
modframes = {}
for mod in modnames:
filename = selectionmod + modnames[mod]
modframes[mod] = YImage(filename, settings, scale).img
return modframes
def prepare_cursor(scale, settings):
"""
:param settings:
:param path: string of path, without filename
:param scale: float
:return: [PIL.Image]
"""
yimg = YImage(cursor, settings, scale)
frame = [yimg.img]
return frame, yimg.imgfrom == ImageFrom.DEFAULT_X or yimg.imgfrom == ImageFrom.DEFAULT_X2
def prepare_inputoverlaybg(scale, settings): """ :param settings: :param path: string of path, without filename :param scale: float :return: [PIL.Image] """ yimg = YImage(bg, settings, scale, scaley=scale * 1.05) img = yimg.img.transpose(Image.ROTATE_270) frame = [img] return frame
def prepare_scorebarbg(scale, backgroundframe, settings):
"""
:param settings:
:param backgroundframe: [Pillow.Image] second index is the gameplay background
:param scale: float
:return: [PIL.Image]
"""
img = YImage(scorebarbg, settings, scale).img
img2 = backgroundframe[1].copy()
img2.paste(img, (0, 0), mask=img)
return [img, img2]
def prepare_rankinghitresults(scale, settings):
scores_frames = {}
scale *= 0.5
bonus = {100: "k", 300: "g"}
for x in [0, 50, 100, 300]:
yimg = YImage(hitprefix + str(x), settings, scale)
scores_frames[x] = yimg.img
if x > 50:
yimg = YImage(hitprefix + str(x) + bonus[x],
settings,
scale,
fallback="reeee")
img = yimg.img
if yimg.imgfrom == ImageFrom.BLANK:
yimg = YImages(hitprefix + str(x) + bonus[x],
settings,
scale,
delimiter="-")
img = yimg.frames[0]
scores_frames[x + 5] = img
return scores_frames
def prepare_cursormiddle(scale, settings, default=False):
# if default:
# path = settings.default_path
# else:
# path = settings.path
# exists = os.path.isfile(path + cursormiddle + settings.format)
yimg = YImage(cursormiddle,
settings,
scale,
defaultpath=default,
defaultfallback=default)
frame = [yimg.img]
return frame, yimg.imgfrom != ImageFrom.BLANK
def prepare_scoreentry(scale, color, settings): """ :param settings: :param path: string of path, without filename :param scale: float :param color: tuple(R, G, B) :return: [PIL.Image] """ numbers_animation = [] for x in range(10): number = YImage(scoreentry + str(x), settings, scale) img = number.img tmp = imageproc.add_color(img, color) numbers_animation.append(shrink(tmp, 0.9, 0.3, 0.05 * 60/settings.fps)) return numbers_animation
def prepare_cursortrail(scale, continuous, settings):
"""
:param path: string
:param scale: float
:return: [PIL.Image]
"""
if continuous:
end = 1.5
else:
end = 1
yimg = YImage(cursortrail, settings, scale)
trail_frames = fadein(yimg.img, 0.1, end, 0.1)
trail_frames = grow(trail_frames, 0.9, 1, 0.1 / 9)
trail_frames.append(Image.new("RGBA", (1, 1)))
return trail_frames
def prepare_hitcirclenumber(diff, scale, settings):
"""
:param diff:
:param scale:
:return: [PIL.Image]
"""
circle_radius = (54.4 - 4.48 * diff["CircleSize"]) * scale * 0.8
hitcircle_number = []
scale = circle_radius * 2 / default_circle_size
scale *= 1.05
for x in range(10):
img = YImage("-{}".format(str(x)),
settings,
scale,
prefix="HitCirclePrefix")
hitcircle_number.append(img.img)
return hitcircle_number, scale
def prepare_approach(scale, time_preempt, settings):
"""
:param settings:
:param scale: float
:param time_preempt: the time the circle is on screen
:return: [PIL.Image]
"""
img = YImage(approachcircle, settings).img
approach_frames = []
s = 3.5
interval = settings.timeframe / settings.fps
for time_left in np.arange(time_preempt, 0, -interval):
s -= 2.5 * interval / time_preempt
p = imageproc.change_size(img, s * scale, s * scale)
approach_frames.append(p)
return approach_frames
def prepare_scorebar(scale, settings):
"""
:param settings:
:param scale: float
:return: [PIL.Image]
"""
yimg = YImages(scorebar, settings, scale, delimiter="-")
img = yimg.frames
defaultpath = yimg.imgfrom == ImageFrom.DEFAULT_X or yimg.imgfrom == ImageFrom.DEFAULT_X2
yimgmarker = YImage(scorebarmarker,
settings,
scale,
defaultpath=defaultpath,
fallback="reeee")
marker = yimgmarker.img
hasmarker = yimgmarker.imgfrom != ImageFrom.BLANK
return img, marker, hasmarker
def prepare_playinggrade(scale, settings): frames = [] grades = ["XH", "SH", "X", "S", "A", "B", "C", "D"] for grade in grades: img = YImage(ranking + grade + "-small", settings, scale).img step = settings.timeframe/1000 * 60/settings.fps effects = grow(img, 1, 2, step * 0.05) effects = fadeout(effects, 1, 0, step * 0.05) for x in effects: imageproc.add(img, x, x.size[0]/2, x.size[1]/2, channel=4) effects.append(img) frames.append(effects) # frameshd = [YImage(ranking + "XH-small", settings, scale).img, YImage(ranking + "SH-small", settings, scale).img] # frameshd.extend(frames[2:]) framesnm = frames[2:] frameshd = frames[:2] + frames[4:] return framesnm, frameshd
def prepare_spinner(scale, settings):
scale = scale * 1.3 * 0.5
spinner_images = {}
n = [
spinnercircle, spinnerbackground, spinnermiddle, spinnermiddle2,
spinnerspin, spinnermetre, spinnerbottom, spinnerrpm
]
spinv2 = False
for img in n:
yimage = YImage(img, settings, scale)
spinner_images[img] = imageproc.newalpha(yimage.img, 0.75)
if img == spinnerbackground and yimage.imgfrom == ImageFrom.BLANK:
spinv2 = True
if spinv2:
spinner_images[spinnerbackground] = spinner_images[spinnermiddle]
maxwidth = max(spinner_images[spinnerbottom].size[0],
spinner_images[spinnermiddle2].size[0])
maxheight = max(spinner_images[spinnerbottom].size[1],
spinner_images[spinnermiddle2].size[1])
circle = Image.new("RGBA", (maxwidth, maxheight))
imageproc.add(spinner_images[spinnermiddle2],
circle,
circle.size[0] / 2,
circle.size[1] / 2,
channel=4)
imageproc.add(spinner_images[spinnerbottom],
circle,
circle.size[0] / 2,
circle.size[1] / 2,
channel=4)
spinner_images[spinnercircle] = circle
spinner_images[spinnermetre] = Image.new("RGBA", (1, 1))
return spinner_images
def prepare_rankingpanel(scale, background, settings):
"""
:param settings:
:param scale: float
:param background: PIL.Image
:return: [PIL.Image]
"""
yimg = YImage(rankingpanel, settings, scale)
img = yimg.img
blackbar = Image.new("RGBA", (background[-1].size[0], int(100 * scale)),
(0, 0, 0, 200))
bg = background[-1].copy()
if settings.skin_ini.general["Version"] == 1:
y = 74
else:
y = 102
imageproc.add(img, bg, 0, y * scale, topleft=True)
imageproc.add(blackbar, bg, 0, 0, topleft=True)
return [bg]
def prepare_inputoverlay(scale, color, index_c, settings): """ :param settings: :param scale: float :param color: tuple(R, G, B) :param index_c: index of the color that changes (fadeout fadein) :return: [PIL.Image] """ yimg = YImage(inputoverlay, settings, scale) color = np.array(color) color[index_c] += 200 color[color > 255] = 255 start, end, step = 1, 0.77, 0.05 * 60/settings.fps c_step = int(200*step/(start - end - step)) button_frames = shrink(yimg.img, start, end, step) for i, img in enumerate(button_frames): imgc = imageproc.add_color(img, color) button_frames[i] = imgc color[index_c] = max(0, color[index_c] - c_step) button_frames.insert(0, yimg.img) return button_frames
def prepare_scoreboardscore(scale, settings):
"""
:param settings:
:param path: string of path, without filename
:param scale: float
:param color: tuple(R, G, B)
:return: [PIL.Image]
"""
scale = scale * 0.8
numbers_animation = []
for x in range(12):
if x == 10:
x = "x"
if x == 11:
x = "dot"
number = YImage(scoreentry + str(x), settings, scale)
if number.imgfrom == ImageFrom.BLANK:
img = Image.open(
os.path.join(settings.path, "res",
scoreentry + str(x) + "@2x.png"))
img = imageproc.change_size(img, scale * 0.5, scale * 0.5)
else:
img = number.img
numbers_animation.append(img)
combo_number = imageproc.change_sizes(numbers_animation, 0.9, 0.9)
combo_number = imageproc.add_color_s(combo_number, [200, 255, 255])
combo_number = scorelist_to_dict(combo_number)
bigger_numbers_animation = imageproc.change_sizes(numbers_animation, 2, 2)
bigger_numbers_animation = scorelist_to_dict(bigger_numbers_animation)
numbers_animation = scorelist_to_dict(numbers_animation)
return numbers_animation, bigger_numbers_animation, combo_number
def __init__(self, scale, settings):
self.score_images = []
scoreprefix = "-"
score_x = scoreprefix + "x"
score_percent = scoreprefix + "percent"
score_dot = scoreprefix + "dot"
for x in range(10):
self.score_images.append(YImage(scoreprefix + str(x), settings, scale, prefix="ScorePrefix"))
self.score_percent = YImage(score_percent, settings, scale, prefix="ScorePrefix")
logger.debug(scale)
# fierymod_v8_realest_ver[1] has very big score_percent.png but it doesn't show up in real osu
# after some testing, if the image is >= 570px then it won't show up
if self.score_percent.orig_cols >= int(570 * scale):
self.score_percent.img = Image.new("RGBA", (self.score_percent.orig_cols, self.score_percent.orig_rows))
self.score_dot = YImage(score_dot, settings, scale, prefix="ScorePrefix")
self.score_x = YImage(score_x, settings, scale, prefix="ScorePrefix")
self.combo_images = []
for x in range(10):
self.combo_images.append(YImage(scoreprefix + str(x), settings, scale, prefix="ComboPrefix"))
self.combo_x = YImage(score_x, settings, scale, prefix="ComboPrefix")
def prepare_rankingtitle(scale, settings):
img = YImage(rankingtitle, settings, scale).img
return [img]
def prepare_urarrow(settings): frame = YImage(urarrow, settings, settings.scale * settings.settings["Score meter size"] * 0.75, defaultpath=True).img imageproc.changealpha(frame, 0.85) return [frame]
def prepare_rankinggraph(scale, settings):
img = YImage(rankinggraph, settings, scale).img
perfectimg = YImages(rankingperfect, settings, scale,
delimiter="-").frames[0]
return [img, perfectimg]
def prepare_rankingreplay(scale, settings):
img = YImage(rankingreplay, settings, scale).img
img = imageproc.newalpha(img, 0.4)
return [img]