path: root/ueditor.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
########################################################################################
# Editor labels for developers
screen units_editor():
    modal True
    frame:
        background Frame("gui/frame.png", 0, 0)
        xalign 0.5
        yalign 0.5
        ymargin 15
        ypadding 10
        xmargin 10

        hbox:
            spacing 30
            xmaximum 0.85
            ymaximum 0.85

            # Navigation
            viewport:
                #child_size (350, 1000)
                mousewheel True
                draggable True
                pagekeys True
                xfill False
                xmaximum 350
                scrollbars "vertical"

                vbox:
                    spacing 2
                    label _("Unit list")
                    $i=0
                    for entry in allunitsbase:
                        textbutton "{size=18}"+_("%d - %s" % (entry["unit_id"], entry["name"]))+"{/size}" action SetVariable("current", i)
                        $i+=1
                    $del i

            # News screen
            viewport:
                #child_size (0.4, 0.8)
                mousewheel True
                #draggable True
                #arrowkeys True
                xfill False
                scrollbars "vertical"

                vbox:
                    xalign 0.5
                    spacing 20

                    $ uedit=allunitsbase[current]

                    label _("%d - %s %s %s" % (uedit["unit_id"], star_write(uedit["rare"]), uedit["name"], ifte(uedit["sex"], "(F)", "(M)")))
                    hbox:
                        spacing 10
                        #textbutton _("-") action Function(ueditor, "unit_id", -1)
                        #label ("%d" % uedit["unit_id"])
                        #textbutton _("+") action Function(ueditor, "unit_id", 1)
                        #def __init__(self, variable, key1, key2, inpu="int", key3=None, key4=None):
                        label _("ID: ")
                        $ input=Input(
                            value=UEditorInputValue(uedit, "unit_id", None, "int", dp=True),
                            copypaste=True,
                            allow="0123456789",
                            length=8)
                        button:
                            #key_events True
                            action input.enable
                            add input

                    null height 25
                    label _("Base ID %d" % uedit["unit_base_id"])
                    label _("Flavor text:")
                    label _(uedit["flavor"])
                    null height 25

                    label _("HP %d" % uedit["hp"])
                    label _("ATK %d" % uedit["strength"])
                    label _("Max Lv. %d" % uedit["max_level"])
                    null height 25

                    label _("Attribute %d" % uedit["attribute"])
                    label _("Job %d" % uedit["job"])
                    label _("Flags %d" % uedit["flags"])
                    null height 25

                    label _(".:: Active Skill ::.")
                    label _("ID %d" % uedit["skill_id"])
                    # TODO: Open skills.json and parse the IDs
                    null height 25

                    label _(".:: Passive ::.")
                    label _("ID %d" % uedit["ability_id"])
                    # TODO: Open skills.json and parse the IDs
                    null height 25

                    # TODO: Loot, waves
                    ###########################################
                    null height 40
                    hbox:
                        spacing 25

                        textbutton _("Save") action Function(ueditor_save)

                        textbutton _("Close") action Return()
                        textbutton _("New Sub") action Function(ueditor_new, True)
                        textbutton _("New Unit") action Function(ueditor_new)

    ## Right-click and escape refresh screen
    key "game_menu" action Function(RestartInteraction)#Return()
    key "K_RETURN" action Function(RestartInteraction)#Return()

init python:
    import json, copy
    def RestartInteraction():
        renpy.restart_interaction()
        return


    def ueditor(key, operation, override=False):
        global uedit
        uedit=allunitsbase[current]
        print str(uedit["unit_id"])
        if override:
            uedit[key]=operation
        else:
            uedit[key]+=operation
        return

    def ueditor_save():
        global allunitsbase
        f=open(get_path("units.editor.json"), "w")
        json.dump(allunitsbase, f, indent=4, separators=(',', ': '))
        f.close()
        renpy.notify("File saved as units.editor.json")
        return

    def ueditor_new(sub=False):
        global allunitsbase
        if not sub:
            ueid=(100000+len(allunitsbase))*100
        else:
            ueid=allunitsbase[current]["unit_id"]/100*100 # Truncate

        allunitsbase.append({"skill_id": 0,
  "strength": 500,
  "rare": 1,
  "name": "New unit",
  "ability_id": 0,
  "attribute": 1,
  "hp": 500,
  "unit_id": ueid,
  "sex": 0,
  "max_level": 20,
  "job": 1,
  "cost": 1,
  "flags": 0,
  "unit_base_id": ueid/100,
  "flavor": "A standard unit in the game."})
        renpy.notify("New unit added: %d" % ueid)
        return

    def ueditor_addloot():
        global uedit
        uedit=allunitsbase[current]
        uedit["loot"].append(["1000", 0])
        renpy.notify("Added new loot field id 1000 (an invalid ID)")
        return

    def ueditor_addmonster(wave):
        global uedit
        uedit=allunitsbase[current]
        pointer=uedit["waves"][wave-1]
        if len(pointer) < 3:
            pointer.append({
                "name": "New Monster",
                "sprite": 950000,
                "attribute": 1,
                "boss": False
            })
        else:
            renpy.notify("Max monsters per wave reached!")
        return

    def ueditor_addwave():
        global uedit
        uedit=allunitsbase[current]
        uedit["waves"].append([])
        renpy.notify("Blank wave created\nThis is buggy, remember to add monsters")
        return


    def ueditor_delete(key1, key2=None, key3=None, key4=None):
        global uedit
        uedit=allunitsbase[current]
        if key2 is None:
            del uedit[key1]
            #del allunitsbase[current][key1]
        elif key3 is None:
            del uedit[key1][key2]
            #del allunitsbase[current][key1][key2]
        elif key4 is None:
            del uedit[key1][key2][key3]
            #del allunitsbase[current][key1][key2][key3]
        else:
            del uedit[key1][key2][key3][key4]
            #del allunitsbase[current][key1][key2][key3][key4]
        return

    def ueditor_input(key1, key2=None, tp="int", temp="", key3=None, key4=None):
        #temp=renpy.input("Please insert new value for this variable.\nCurrent value: [variable]")
        global uedit
        uedit=allunitsbase[current]
        variable=""

        # Key looping
        if key2 is None:
            target=uedit[key1]
        elif key3 is None:
            target=uedit[key1][key2]
        elif key4 is None:
            target=uedit[key1][key2][key3]
        else:
            target=uedit[key1][key2][key3][key4]

        # Convert input if needed
        # tp int → convert to int
        # tp key → Replace the key
        # tp bool → Toogles the value
        if tp == "int":
            try:
                variable=int(temp)
            except:
                renpy.notify("Invalid numeric input")
                variable=0 # Sorry, but gets bad otherwise
        elif tp == "key":
            try:
                uedit[key1][temp]=copy.copy(target)
                renpy.notify("Key replaced")
                del uedit[key1][key2] # Not sure "del target" would work
                return
            except:
                renpy.notify("ERROR, doing nothing")
                variable=target
        elif tp == "bool":
            try:
                variable=(not target)
                print "New boolean: %s" % str(variable)
            except:
                print "Illegal boolean"
                renpy.notify("Illegal boolean")
                variable=target
        else:
            try:
                variable=str(temp)
            except:
                renpy.notify("Invalid string input")

        # Save input
        # Key looping
        if key2 is None:
            target=uedit[key1]=variable
        elif key3 is None:
            target=uedit[key1][key2]=variable
        elif key4 is None:
            target=uedit[key1][key2][key3]=variable
        else:
            target=uedit[key1][key2][key3][key4]=variable

        return


    class UEditorInputValue(InputValue):
        def __init__(self, variable, key1, key2, inpu="int", key3=None, key4=None, dp=False):
            try:
                self.variable = variable
            except:
                self.variable = ""
            self.inpu = inpu
            self.short_display = dp

            self.default=True
            self.editable=True

            self.key1=key1
            self.key2=key2
            self.key3=key3
            self.key4=key4

        def get_text(self):
            try:
                if not self.short_display:
                    return str(self.variable)
                else:
                    return str(self.variable[self.key1])
            except:
                traceback.print_exc()
                return ""
            #return globals()[self.variable]

        def set_text(self, s):
            #globals()[self.variable] = s
            ueditor_input(self.key1, self.key2, self.inpu, s, key3=self.key3, key4=self.key4)

        def enter(self):
            renpy.restart_interaction()
            #renpy.run(self.Disable())
            #raise renpy.IgnoreEvent()

label units_editors:
    $ uedit=allunitsbase[0]
    $ current=0
    $print("")
    $print(".:: THE BUILT-IN QUEST EDITOR ::.")
    $print("Use ESC to redraw screen, saving input")
    $print("")
    call screen units_editor
    $print("Quest Editor closed")
    menu:
        "Save Changes":
            $ ueditor_save()
        "Discard Changes":
            pass
    jump restore