path: root/game/defs.rpy

########################################################################################
#     This file is part of Spheres.
#     Copyright (C) 2019  Jesusalva

#     This library is free software; you can redistribute it and/or
#     modify it under the terms of the GNU Lesser General Public
#     License as published by the Free Software Foundation; either
#     version 2.1 of the License, or (at your option) any later version.

#     This library is distributed in the hope that it will be useful,
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#     Lesser General Public License for more details.

#     You should have received a copy of the GNU Lesser General Public
#     License along with this library; if not, write to the Free Software
#     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
########################################################################################
# Definitions

init -3 python:
    renpy.add_python_directory("python-extra")
    import requests, zlib, base64, sys, copy

    # set PYTHON_VERSION variable (should be 2713, 3605 could fail)
    PYTHON_VERSION="%d%d%02d" % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
    PYTHON_VERSION=int(PYTHON_VERSION)

    # Ren'Py should come with Python 2.7.10 (2710), but just in case
    # After all, I only tested with 2.7.10, 2.7.13 and 2.7.15
    if (PYTHON_VERSION < 2700 or PYTHON_VERSION > 3000):
        raise Exception("WARNING: Python version is not 2.7\nStrange bugs may happen on your client.\n\nClick on \"Ignore\" to continue.\nClick on \"Quit\" to exit.")

    # Why setting this...?
    ApTimer=""

    # Configuration
    config.autoreload = False
    config.save_on_mobile_background = False
    persistent.release_name = "Renewal"
    if persistent.host is None:
        persistent.host="spheres.tmw2.org"
        # FIXME: Set good defaults (=bad) for Android
        if renpy.android:
            persistent.nothreading=True
            persistent.fatality=True
    if (persistent.allfiles is None):
        persistent.allfiles=[]
    allfiles=[]
    HOST=str(persistent.host)
    PORT=10301
    UPDP=10302
    FAILUREMSG="Request failed, Please try again"
    OFFLINEMSG="401 Unauthorized"
    OKMSG="200 OK"
    TIMEOUT_INTERVAL=3.0
    MAX_IRC_BUFFER=50
    SSL_IS_BROKEN=False
    debug=copy.copy(config.developer)

    # Error Codes
    ERR_JSONDECODER=101
    ERR_LOGIN_DEFAULT=102
    ERR_INVALID=103
    ERR_TIMEOUT=104
    ERR_NOGEMS=105
    ERR_INVFULL=106
    ERR_OK=200

    # All error code library
    ERRNO=[FAILUREMSG, OFFLINEMSG, OKMSG, ERR_LOGIN_DEFAULT, ERR_INVALID, ERR_TIMEOUT, ERR_NOGEMS, ERR_INVFULL, ERR_OK]

    # Core musics/sfx
    MUSIC_OPENING="sfx/bgm01.mp3"
    MUSIC_TOWN="sfx/bgm02.mp3"

    # Spheres actions
    AP_NONE     =False
    AP_SPHERE   =1
    AP_SKILL    =2

    # Status
    ST_TOWN     =0
    ST_QUEST    =1

    # Unit flags
    UF_NOLVL    =1
    UF_NOPART   =2
    UF_EXPUP    =4
    UF_EVOMAT   =8
    UF_SUPEREVO =64

    # Jobs
    Job_Swordsman   =1
    Job_Assassin    =2
    Job_Mage        =3
    Job_Archer      =4
    Job_Gunner      =5

    # IRC flags
    IRC_AUTH_NONE   =0
    IRC_AUTH_USER   =1
    IRC_AUTH_NICK   =2
    IRC_AUTH_CHAN   =3

    # Smart Print command
    def stdout(message):
        if debug:
            if renpy.android:
                if not renpy.is_init_phase():
                    renpy.notify(message)
            else:
                print(message)
            renpy.write_log("[DEBUG] %s" % message)
        else:
            renpy.write_log("[GAME] %s" % message)
        return

    # Global classes
    # We need to override standard list method. Original by Triptych (stackoverflow)
    class dlist(list):

        def __setitem__(self, index, value):
            size = len(self)
            if index >= size:
                self.extend(None for _ in range(size, index + 1))

            list.__setitem__(self, index, value)

    class ExecuteOnCall():
        def __init__(self, callable, *args, **kwargs):
            self.callable = callable
            self.args = args
            self.kwargs = kwargs

        def __call__(self):
            rv = self.callable(*self.args, **self.kwargs)
            return rv

        def id(self):
            return self.__call__()

    class RetString():
        def __init__(self, string):
            self.string = string

        def __call__(self):
            return self.string

        def id(self):
            return self.__call__()

    # Screen Functions/class
    # Override
    class SpheresMainMenu(MainMenu):
        def __call__(self):

            if not self.get_sensitive():
                return

            if self.confirm:
                if config.autosave_on_quit:
                    renpy.force_autosave()

                layout.yesno_screen(layout.MAIN_MENU, SpheresMainMenu(False))
            else:
                # Flush labels/sockets/timers as needed
                renpy.call_in_new_context("quit")
                # Restart
                renpy.full_restart(config.game_main_transition)

    class ExtraImage(renpy.display.im.Image):
        """
        Custom image manipulator, based on bink's code, topic 11732
        """

        def __init__(self, loc, **properties):
            """
            @param loc: Where the image really is (get_path already applied)
            """

            super(ExtraImage, self).__init__(loc, **properties)
            self.loc = loc

        def load(self, unscaled=False): # W0221
            try:
                #page = open(self.loc, "rb")
                #pd = page.read()
                #picdata = os.tmpfile()
                #picdata.write(pd)
                #picdata.seek(0) # reset seek position
                stdout("Requested to open: %s" % repr(self.loc))
                picdata = open(self.loc, "rb")
                stdout("Picdata is open (%s)" % self.loc)

                if unscaled:
                    surf = renpy.display.pgrender.load_image_unscaled(picdata, self.loc)
                else:
                    surf = renpy.display.pgrender.load_image(picdata, self.loc)

                stdout("Picdata was closed")
                picdata.close()
                #page.close()

                return surf
            except Exception, e:
                if renpy.config.missing_image_callback:
                    im = renpy.config.missing_image_callback(self.loc)
                    if im is None:
                        raise e
                    return im.load()
                raise

    def virtpos(posix):
        if isinstance(posix, float):
            return posix*1024
        else:
            return posix/1024.0

    # File Managment Functions
    def get_path(path):
        if renpy.android:
            #print "Android detected"
            path=path.replace("/", "_")
            #return renpy.loader.get_path(path)
            return renpy.config.savedir + "/" + path
        else:
            return renpy.loader.get_path(path)

    def get_path_if_exists(path):
        if renpy.android:
            print "Android detected, not checking"
            path=path.replace("/", "_")
            #return renpy.loader.get_path(path)
            return renpy.config.savedir + "/" + path
        else:
            return renpy.loader.transfn(path)

    # URL3 Function
    def GAME_UPDATER():
        global tr_load
        tr_load=False

        # If no version is provided, we are using default files
        # Default files version is "1" (Should never happen)
        if (persistent.version is None):
            persistent.version=1

        # Download upstream version
        x=requests.get("http://"+HOST+'/version.txt')
        try:
            ver=int(x.text)
        except:
            stdout("IMPOSSIBLE TO DETERMINE VERSION")
            raise Exception("Could not estabilish a connection to update server:\n%s is not valid." % x.text) # TODO: Show this beautifully?
            # TODO: Should we set a "ver"?

        if (int(persistent.version) < ver):
            # Check if the server have SSL support
            try:
                stdout("Downloading certificate from server")
                x=requests.get("http://"+HOST+'/certificate.pem')
                #print len(x.text)
                if "BEGIN CERTIFICATE" in x.text:
                    persistent.ssl_enabled=True
                    stdout("Updating server certificate")
                    f=open(get_path("cert/certificate.pem"), "w")
                    f.write(x.text)
                    f.close()
                    stdout("SSL: ENABLED")
                else:
                    raise Exception("Not a certificate")
            except:
                stdout("SSL: DISABLED")
                persistent.ssl_enabled=False

            # Download quests.json
            f=open(get_path("quests.json"), "w")
            stdout("Downloading quests.json")
            x=requests.get("http://"+HOST+'/quests.json')
            f.write(x.text)
            f.close()

            # Download units.json
            f=open(get_path("units.json"), "w")
            stdout("Downloading units.json")
            x=requests.get("http://"+HOST+'/units.json')
            f.write(x.text)
            f.close()

            # Download story.json
            f=open(get_path("story.json"), "w")
            stdout("Downloading story.json")
            x=requests.get("http://"+HOST+'/story.json')
            f.write(x.text)
            f.close()

            # Download world.json
            f=open(get_path("world.json"), "w")
            stdout("Downloading world.json")
            x=requests.get("http://"+HOST+'/world.json')
            f.write(x.text)
            f.close()

            # Download bar.json
            f=open(get_path("bar.json"), "w")
            stdout("Downloading bar.json")
            x=requests.get("http://"+HOST+'/bar.json')
            f.write(x.text)
            f.close()

            # Download summons.json
            f=open(get_path("summons.json"), "w")
            stdout("Downloading summons.json")
            x=requests.get("http://"+HOST+'/summons.json')
            f.write(x.text)
            f.close()

            persistent.version=ver
            stdout("Update complete")

        # Download server news
        # Handled by GAME_LOADER

        tr_load=True
        return tr_load





############################################################################
init -1 python:
    import socket, sys, time, json
    if renpy.android:
        try:
            import androidssl as ssl
        except:
            SSL_IS_BROKEN=True
            import ssl
            stdout("Broken Android SSL detected, FALLING BACK")
    else:
        import ssl
        print("Using system-wide SSL implementation...")

    print("======================= %s %s %s" % (config.name, config.version, persistent.release_name))
    print "[STDBY] Loading Basic functions......."

    # Search for array[?][key]==search in an array of dicts
    # Returns the dictionary, or returns ERR_INVALID
    def dl_search(array, key, search):
        try:
            r=(item for item in array if item[key] == search).next()
        except:
            r=ERR_INVALID
        if r is None:
            r=ERR_INVALID
            stdout("dlsearch: r is None")
        return r

    def check_fail(raw):
        global debug, FAILUREMSG

        if (debug):
            stdout(str(raw))
        if (raw == FAILUREMSG):
            return True
        return False

    def json_decode(raw):
        global ERRNO

        if (check_fail(raw)):
            return ERR_LOGIN_DEFAULT

        # TODO Move this to check_fail and rewrite check_fail
        # ERR_OFF should be handled top-level no? With full_restart()
        if raw in ERRNO:
            return raw

        try:
            return int(raw)
        except:
            pass

        # Maybe base 64
        try:
            rw=base64.b64decode(raw)
            raw=rw
            if (debug):
                print "base64 decoded"
        except:
            pass

        # Maybe zlib compressed
        try:
            rw=zlib.decompress(raw)
            raw=rw
            if (debug):
                print str(raw)
        except:
            pass

        # Decode JSON
        try:
            return json.loads(raw)
        except:
            return ERR_JSONDECODER

    def get_token():
        try:
            t=Player['token']
        except:
            t="0" #"f528764d624db129b32c21fbca0cb8d6"
        return t

    def login():
        global Player
        stdout("Login requested for %s" % logindata())
        raw=send_packet("login", logindata())

        Player=json_decode(raw)
        if (Player == ERR_JSONDECODER):
            return ERR_JSONDECODER
        if (Player == ERR_LOGIN_DEFAULT):
            return ERR_LOGIN_DEFAULT

        try:
            Player["inv"]=dlist()
        except:
            pass
        return Player["code"]

    def send_packet_now(packet, args="", legacy=False):
        global tr_load, tr_val
        try:
            sock80 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            if not renpy.android:
                sock80.settimeout(10)
            else:
                    stdout("RAW Socket Ready")

            # TODO: Request server if it is running with SSL or not
            # If SSL is enabled (server configuration)
            if persistent.ssl_enabled:
                if not SSL_IS_BROKEN:
                    # Create the contest
                    context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)

                    # Protect the most possible, if appliable.
                    context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1

                    # FIXME We should check it
                    if persistent.ssl_enabled != "IGNORE":
                        context.check_hostname = True
                        context.verify_mode = ssl.CERT_OPTIONAL
                    else:
                        stdout("[SECURITY] SSL VERIFICATION DISABLED.")
                        context.check_hostname = False
                        context.verify_mode = ssl.CERT_NONE
                    #context.load_default_certs() # <- A .crt file
                    context.load_verify_locations(get_path("cert/certificate.pem"))
                    stdout("SSL Context Ready")

                    sock = context.wrap_socket(sock80, server_hostname=HOST)
                else:
                    CIPHERS_OVERRIDE = ":".join(
                        [
                            "ECDHE+AESGCM",
                            #"ECDHE+CHACHA20",
                            #"DHE+AESGCM",
                            #"DHE+CHACHA20",
                            "ECDH+AESGCM",
                            #"DH+AESGCM",
                            "ECDH+AES",
                            #"DH+AES",
                            "RSA+AESGCM",
                            "RSA+AES",
                            #"!aNULL",
                            #"!eNULL",
                            #"!MD5",
                            #"!DSS",
                        ]
                    )
                    if persistent.ssl_enabled != "IGNORE":
                        sock = ssl.wrap_socket(sock80, ca_certs=get_path("cert/certificate.pem"), ssl_version=2, cert_reqs=ssl.CERT_OPTIONAL, ciphers=CIPHERS_OVERRIDE)
                    else:
                        stdout("[SECURITY] SSL VERIFICATION DISABLED.")
                        sock = ssl.wrap_socket(sock80, ca_certs=get_path("cert/certificate.pem"), ssl_version=2, cert_reqs=ssl.CERT_NONE, ciphers=CIPHERS_OVERRIDE)
                    stdout("Android SSL Wrapper Ready")

            else:
                sock=sock80

            if not renpy.android:
                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            else:
                stdout("Socket Ready")

            sock.connect((HOST, PORT))

            if renpy.android:
                stdout("Socket Ready")
                stdout("Connected: (%s, %d), Socket %s" % (HOST, PORT, sock.getsockname()))
                renpy.pause(1.0)

            #m=get_token() + ";" + packet
            m=get_token() + ";" + packet + ";" + args

            stdout("Sending: %s" % m)
            sock.sendall(m)

            # Receive data from the server
            received = sock.recv(2048)
            stdout("received: %s" % received)

            # Close the socket
            sock.shutdown(socket.SHUT_RDWR)
            sock.close()
        except:
            received=FAILUREMSG

            if persistent.fatality is not None:
                raise

        # Legacy support (for ping)
        if legacy:
            return received

        tr_load=True
        tr_val=str(received)
        return

    def send_packet(packet, args=""):
        global tr_load, tr_val
        # This is a secret variable which disables threading
        # This may cause hangs and other issues.
        if persistent.nothreading:
            send_packet_now(packet, args)
            val=tr_val
            return val

        timeout=0.0
        tr_load=False
        tr_val=None
        renpy.show("spinner", at_list=[truecenter])
        renpy.invoke_in_thread(send_packet_now, packet, args)
        while not tr_load:
            renpy.pause(0.1)
            timeout+=0.1

            if timeout >= TIMEOUT_INTERVAL:
                # FIXME: What if a screen is already being displayed? BUG
                try:
                    renpy.call_screen("msgbox", "Error Code: %d\n\nApplication timeout, click to try again" % (ERR_TIMEOUT))
                    timeout=0.0
                except:
                    if not "ping" in packet.lower():
                        stdout("WARNING, ILLEGAL PACKET ON SCREEN TIME: %s" % packet)
                    pass

        renpy.hide("spinner")
        val=tr_val
        del tr_val

        print "value obtained"
        if (val is None):
            return ERR_INVALID
        return val

    def GAME_LOADER():
        global allunitsbase, allunits, allquests, allstory, allworld, alltaverns
        global allnews, tr_load
        tr_load=False

        # Load unit data
        if renpy.android:
            allunitsbase=json.loads(requests.get("http://"+HOST+'/units.json').text)
        else:
            f=open(get_path_if_exists("units.json"), "r")
            allunitsbase=json.load(f)
            f.close()

        # Reorder unit data
        allunits={}
        for j in allunitsbase:
            allunits[j["unit_id"]]=j

        # Load summons data
        f=open(get_path_if_exists("summons.json"), "r")
        allworld=json.load(f)
        f.close()

        # Load quest data
        f=open(get_path_if_exists("quests.json"), "r")
        allquests=json.load(f)
        f.close()

        # Load story data
        f=open(get_path_if_exists("story.json"), "r")
        allstory=json.load(f)
        f.close()

        # Load world data
        f=open(get_path_if_exists("world.json"), "r")
        allworld=json.load(f)
        f.close()

        # Load tavern data
        f=open(get_path_if_exists("bar.json"), "r")
        alltaverns=json.load(f)
        f.close()

        # Load server news
        try:
            allnews=json.loads(requests.get("http://"+HOST+'/news.json', timeout=5.0).text)
        except:
            allnews=[]
            pass

        print "[OK] Basic functions loaded"
        tr_load=True
        return tr_load





############################################################################
# This is the JSON data formatter
init python:
    import json
    def logindata():
        global password
        # TODO: Obtain user id based on device
        return """{
                "passwd": "%s",
                "version": "%s"
                }""" % (password, config.version)


    def recruitdata(t, a):
        return """{
                "tavern": %d,
                "amount": %d
                }""" % (t, a)


    def questdata(q, p):
        return """{
                "quest_id": %d,
                "party_id": %d
                }""" % (q, p)


    def battledata(u, s):
        return """{
                "unit": %s,
                "sphere": %s
                }""" % (json.dumps(u), json.dumps(s))

    def card_composite(cid, path):
        # We need to try to get rarity
        try:
            r=allunits[int(cid)]["rare"]
        except:
            r=4 # FIXME

        # We need to try to get the element
        try:
            e=allunits[int(cid)]["attribute"]
            print str(e)
        except:
            e=0

        return Composite(
            (640, 960),
            (0, 0), "gfx/cards/bg.png",
            (0, 0), path,
            (0, 0), "gfx/cards/"+str(r)+".png",
            (0, 0), "gfx/cards/ele/"+str(e)+".png")
        # size,)

    # TODO: square_ and gfx/square/units
    # Converts regular image filepaths to displayables names and vice-versa
    def img_regex(name, reverse=False):
        if not reverse:
            # Extension is ommited, add them yourself!
            if name.startswith("unit_"):
                return "gfx/units/%s" % name.replace("unit_")
            elif name.startswith("mob_"):
                return "gfx/mobs/%s" % name.replace("mob_")
            elif name.startswith("dialog_"):
                return "gfx/dialog/%s" % name.replace("dialog_")
            elif name.startswith("bg "):
                return "gfx/bg/%s" % name.replace("bg ")
            elif name.startswith("summon_"):
                return "gfx/summons/%s" % name.replace("summon_")
            else:
                print("ERROR: Not a regular filename")
                return name
        else:
            if name.startswith("gfx/units/"):
                return "unit_%s" % name
            elif name.startswith("gfx/mobs/"):
                return "mob_%s" % name
            elif name.startswith("gfx/dialog/"):
                return "dialog_%s" % name
            elif name.startswith("gfx/bg/"):
                return "bg %s" % name
            elif name.startswith("gfx/summons/"):
                return "summon_%s" % name
            else:
                print("ERROR: Not a regular display name")
                return name

    # Loads a sound called VAL
    def get_sfx(val, ext):
        # Search for the sound
        show_img(val, False, ext=ext)

        valb=dl_search(persistent.allfiles, 0, val)[1]
        if valb == ERR_INVALID:
            print ("Invalid Sound: %s (%s)" % (path, val))
            return "sfx/regnum.mp3" # FIXME
        return valb

    # Load sprite images: "unit"
    for file in renpy.list_files():
        fn=file.replace('gfx/units/','').replace('/', ' ').replace('.png','')
        if file.startswith('gfx/units/'):
            if file.endswith('.png') or file.endswith('.webp'):
                name = "unit_"+fn
                #renpy.image(name, Image(file, yanchor=1.0))
                renpy.image(name, card_composite(fn, file))

                dl=dl_search(persistent.allfiles, 0, name)
                if dl is not ERR_INVALID:
                    persistent.allfiles.append((name, file))
                allfiles.append(name)
                continue
            continue

    # Load sprite images: "mob"
    for file in renpy.list_files():
        fn=file.replace('gfx/mobs/','').replace('/', ' ').replace('.png','')
        if file.startswith('gfx/mobs/'):
            if file.endswith('.png') or file.endswith('.webp'):
                name = "mob_"+fn
                renpy.image(name, Image(file, yanchor=1.0))
                if not name in persistent.allfiles:
                    persistent.allfiles.append((name, file))
                allfiles.append(name)
                continue
            continue


    # Load sprite images: "dialog"
    for file in renpy.list_files():
        fn=file.replace('gfx/dialog/','').replace('/', ' ').replace('.png','').replace('.webp','')
        if file.startswith('gfx/dialog/'):
            if file.endswith('.png') or file.endswith('.webp'):
                name = "dialog_"+fn
                renpy.image(name, Image(file, yanchor=1.0))
                dl=dl_search(persistent.allfiles, 0, name)
                if dl is not ERR_INVALID:
                    persistent.allfiles.append((name, file))
                allfiles.append(name)
                continue
            continue


    # Load background images: "bg"
    for file in renpy.list_files():
        fn=file.replace('gfx/bg/','').replace('/', ' ').replace('.png','').replace('.webp','')
        if file.startswith('gfx/bg/'):
            if file.endswith('.png') or file.endswith('.webp'):
                name = "bg "+fn
                renpy.image(name, Frame(file, 0, 0))
                dl=dl_search(persistent.allfiles, 0, name)
                if dl is not ERR_INVALID:
                    persistent.allfiles.append((name, file))
                allfiles.append(name)
                continue
            continue


    # Load summon images: "summon"
    for file in renpy.list_files():
        fn=file.replace('gfx/summons/','').replace('/', ' ').replace('.png','').replace('.webp','')
        if file.startswith('gfx/summons/'):
            if file.endswith('.png') or file.endswith('.webp'):
                name = "summon_"+fn
                renpy.image(name, Image(file, yanchor=1.0))
                dl=dl_search(persistent.allfiles, 0, name)
                if dl is not ERR_INVALID:
                    persistent.allfiles.append((name, file))
                allfiles.append(name)
                continue
            continue

    def star_write(am):
        i, st = 0, ""
        while i < am:
            i+=1
            st+="★"
        return st


    # Overrides renpy.image() method
    def new_img(name, where):
        # d: Downloaded path
        if not isinstance(name, tuple):
            name = tuple(name.split())

        #d = renpy.renpy.easy.displayable(where)
        if renpy.android:
            d=ExtraImage(where)
        else:
            d = renpy.renpy.easy.displayable(where)
        renpy.renpy.display.image.register_image(name, d)
        return

    # Retrieves Ren'Py displayable name associated to PATH
    def get_img(path):
        # Search for the image name
        val=img_regex(path, True)
        show_img(val, False)

        valb=dl_search(persistent.allfiles, 0, val)[1]
        if valb == ERR_INVALID:
            print ("Invalid Image: %s (%s)" % (path, val))
            return "gfx/spinner.png"
        return valb

    # Overrides renpy.show() and renpy.image() methods
    # Missing: transient=False, munge_name=True
    def show_img(img, show=True, at_list=[ ], tag=None, zorder=None, behind=[ ], atl=None, what=None, layer=None, ext=".png"):
        global tr_loading
        # Image exists, display it
        if img in allfiles:
            if show:
                renpy.show(img, at_list=at_list, tag=tag, zorder=zorder, behind=behind, atl=atl, what=what, layer=layer)
            return

        # Have we downloaded this image previously?
        path=dl_search(persistent.allfiles, 0, img)
        print str(path)

        # Image doesn't exists, we must download it
        while (path == ERR_INVALID):
            tr_loading=True
            # Latest version converts these formats to WebP
            if ext in [".png", ".jpg", ".jpeg"]:
                ext=".webp"
            # Otherwise, preserve extension.
            if renpy.android:
                addr="extra_%s%s" % (img.replace(" ", "_"), ext)
            else:
                addr="extra/%s%s" % (img.replace(" ", "_"), ext)

            f=open(get_path(addr), "w")
            stdout("Downloading additional file: %s" % img.replace(" ", "_"))
            x=requests.get("http://%s:%d/%s?token=%s" % (HOST, UPDP, img.replace(" ", "_"), get_token())) # , timeout=8.0 → Need to handle sudden death
            if x.status_code == 200:
                f.write(x.content)
                f.close()
                # Android needs paths to be saved by full
                if renpy.android:
                    addr=get_path(addr)
                path=((img, addr))
                persistent.allfiles.append(path)
            else:
                try:
                    retry=renpy.call_screen("confirm", "Error downloading file.\nError Code: %d\n\nRetry?" % x.status_code, Return(True), Return(False))
                    if not retry:
                        if tag is None:
                            tag=img
                        path=None
                        if show:
                            renpy.show("spinner", at_list=at_list, tag=tag, zorder=zorder, behind=behind, atl=atl, what=what, layer=layer) # TODO Show error
                        return
                    # TODO: “Retry?”
                except:
                    print("Failed, trying again")

        # Image exists, but wasn't loaded yet
        if (path != ERR_INVALID and path is not None):
            print "Detected not loaded image"
            # Valid Image Extensions: PNG, JPG, JPEG, GIF, WEBP
            if ext in [".png", ".jpg", ".jpeg", ".gif", ".webp"]:
                # Maybe it is an unit
                if img.startswith("unit_"):
                    new_img(img, card_composite(img.replace("unit_", ""), path[1]))
                else:
                    new_img(img, path[1])

            stdout("registered image: "+path[1])
            allfiles.append(img)
            if show:
                renpy.show(img, at_list=at_list, tag=tag, zorder=zorder, behind=behind, atl=atl, what=what, layer=layer)
            tr_loading=False
            return

        # Something went wrong
        stdout("show_img reached abnormal ending")
        return

    ##########################################################
    # Other Music
    MUSIC_BATTLE=RetString("sfx/bgm03.mp3")
    MUSIC_BOSS=RetString("sfx/bgm04.mp3")
    MUSIC_PARTY=RetString("sfx/bgm02.mp3")
    #MUSIC_PARTY=ExecuteOnCall(get_sfx, "sfx_bgm05", ".mp3")#"sfx/bgm05.mp3"
    MUSIC_VICTORY=RetString("sfx/bgm06.mp3")
    MUSIC_WORLDMAP=RetString("sfx/bgm02.mp3")
    #MUSIC_WORLDMAP=ExecuteOnCall(get_sfx, "sfx_bgm07", ".mp3")#"sfx/bgm07.mp3"
    MUSIC_PROLOGUE01=RetString("sfx/regnum.mp3")
    MUSIC_PROLOGUE02=RetString("sfx/prologue.mp3")
    MUSIC_PROLOGUE03=RetString("sfx/shining.mp3")