Initial commit, forked from Spheresinit

1 files changed, 921 insertions, 0 deletions

diff --git a/game/defs.rpy b/game/defs.rpy
new file mode 100644
index 0000000..3d1e18a
--- /dev/null
+++ b/game/defs.rpy
@@ -0,0 +1,921 @@
+########################################################################################
+#     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")
+