support for custom backgrounds

[pmachines.git] / pmachines / editor / scene.py

from copy import deepcopy
from json import dumps
from logging import info
import hashlib
from panda3d.core import Texture, TextNode, LPoint3f
from direct.gui.OnscreenImage import OnscreenImage
from direct.gui.DirectGui import DirectButton, DirectEntry, \
    YesNoDialog, DirectOptionMenu, DirectFrame
from direct.gui.DirectGuiGlobals import FLAT, NORMAL
from direct.gui.OnscreenText import OnscreenText
from direct.showbase.DirectObject import DirectObject
from pmachines.items.test_item import PixelSpaceTestItem, WorldSpaceTestItem
from pmachines.editor.scene_list import SceneList
from pmachines.editor.inspector import Inspector, PixelSpaceInspector, WorldSpaceInspector
from pmachines.editor.start_items import StartItems
from ya2.utils.gfx import Point, DirectGuiMixin
from pmachines.editor.augmented_frame import AugmentedDirectFrame
from ya2.utils.gui.base_page import DirectOptionMenuTestable
from pmachines.items.basketball import Basketball
from pmachines.items.box import Box
from pmachines.items.domino import Domino
from pmachines.items.shelf import Shelf
from pmachines.items.teetertooter import TeeterTooter
from pmachines.items.item import FixedStrategy, StillStrategy
from pmachines.items.domino import UpStrategy, DownStrategy
from pmachines.items.box import HitStrategy


class SceneEditor(DirectObject):

    def __init__(self, json, json_name, context, add_item, items, world, mouse_plane_node, pos_mgr):
        super().__init__()
        self.__items = items
        self.__json = json
        self.__world = world
        self.__mouse_plane_node = mouse_plane_node
        self.__pos_mgr = pos_mgr
        self.__dialog = None
        if not json_name:
            self.__json = json = {
                'name': '',
                'instructions': '',
                'version': '',
                'items': [],
                'start_items': [],
                'test_items': {
                    'pixel_space': [],
                    'world_space': []}}
        self.__inspector = None
        self.__context = context
        self.__add_item = add_item
        self._font = base.loader.load_font(
            'assets/fonts/Hanken-Book.ttf')
        self._font.clear()
        self._font.set_pixels_per_unit(60)
        self._font.set_minfilter(Texture.FTLinearMipmapLinear)
        self._font.set_outline((0, 0, 0, 1), .8, .2)
        self.__item_classes = [Basketball, Box, Domino, Shelf, TeeterTooter]
        self.__item_strategy_classes = [FixedStrategy, StillStrategy, HitStrategy, UpStrategy, DownStrategy]
        self._common = {
            'scale': .046,
            'text_font': self._font,
            'text_fg': (.9, .9, .9, 1),
            'relief': FLAT,
            'frameColor': (.4, .4, .4, .14),
            'rolloverSound': loader.load_sfx(
                'assets/audio/sfx/rollover.ogg'),
            'clickSound': loader.load_sfx(
                'assets/audio/sfx/click.ogg')}
        tooltip_args = self._common['text_font'], self._common['scale'], self._common['text_fg']
        w, h, tw, l = 1.8, 1.1, 30, .36
        self._frm = AugmentedDirectFrame(frameColor=(.4, .4, .4, .06),
                                         frameSize=(0, w, 0, h),
                                         parent=base.a2dBottomCenter,
                                         pos=(-w/2, 0, 0),
                                         delta_drag=LPoint3f(0, 0, h),
                                         collapse_pos=(.06, 1, .94),
                                         pos_mgr=self.__pos_mgr,
                                         frame_name='scene')
        OnscreenText(
            _('Filename'), pos=(l - .03, h - .1), parent=self._frm,
            font=self._common['text_font'],
            scale=self._common['scale'],
            fg=self._common['text_fg'],
            align=TextNode.A_right)
        self.__filenamename_entry = DirectEntry(
            scale=self._common['scale'],
            pos=(l, 1, h - .1),
            entryFont=self._font,
            width=tw,
            frameColor=self._common['frameColor'],
            initialText=json_name,
            parent=self._frm,
            text_fg=self._common['text_fg'])
        self.__filenamename_entry['text_fg'] = (1, 0, 0, 1)
        self.__filenamename_entry.__class__ = type('DirectEntryMixed', (DirectEntry, DirectGuiMixin), {})
        self.__filenamename_entry.set_tooltip(_('The name of the file without the extension'), *tooltip_args)
        self.__pos_mgr['editor_scene_filename'] = self.__filenamename_entry.pos_pixel()
        OnscreenText(
            _('Name'), pos=(l - .03, h - .2), parent=self._frm,
            font=self._common['text_font'],
            scale=self._common['scale'],
            fg=self._common['text_fg'],
            align=TextNode.A_right)
        self.__name_entry = DirectEntry(
            scale=self._common['scale'],
            pos=(l, 1, h - .2),
            entryFont=self._font,
            width=tw,
            frameColor=self._common['frameColor'],
            initialText=json['name'],
            parent=self._frm,
            text_fg=self._common['text_fg'])
        self.__name_entry.__class__ = type('DirectEntryMixed', (DirectEntry, DirectGuiMixin), {})
        self.__name_entry.set_tooltip(_('The title of the scene'), *tooltip_args)
        self.__pos_mgr['editor_scene_name'] = self.__name_entry.pos_pixel()
        OnscreenText(
            _('Background'), pos=(l - .03, h - .3), parent=self._frm,
            font=self._common['text_font'],
            scale=self._common['scale'],
            fg=self._common['text_fg'],
            align=TextNode.A_right)
        self.__background_entry = DirectEntry(
            scale=self._common['scale'],
            pos=(l, 1, h - .3),
            entryFont=self._font,
            width=tw,
            frameColor=self._common['frameColor'],
            initialText=json['background'],
            parent=self._frm,
            text_fg=self._common['text_fg'])
        self.__background_entry.__class__ = type('DirectEntryMixed', (DirectEntry, DirectGuiMixin), {})
        self.__background_entry.set_tooltip(_('The name of the background'), *tooltip_args)
        self.__pos_mgr['editor_scene_background'] = self.__background_entry.pos_pixel()
        OnscreenText(
            _('Description'), pos=(l - .03, h - .4), parent=self._frm,
            font=self._common['text_font'],
            scale=self._common['scale'],
            fg=self._common['text_fg'],
            align=TextNode.A_right)
        def add_line_break(txt, entry):
            curpos = entry.node().getCursorPosition()
            entry.set(txt[:curpos]+ "\n" + txt[curpos:])
            entry.node().setCursorPosition(curpos+1)
            entry['focus']=1
        self.__instructions_entry = DirectEntry(
            scale=self._common['scale'],
            pos=(l, 1, h - .4),
            entryFont=self._font,
            width=tw,
            numLines=12,
            cursorKeys=True,
            frameColor=self._common['frameColor'],
            initialText=json['instructions'].replace('\\n', '\n'),
            parent=self._frm,
            text_fg=self._common['text_fg'])
        self.__instructions_entry['command'] = add_line_break
        self.__instructions_entry['extraArgs'] = [self.__instructions_entry]
        self.__instructions_entry.__class__ = type('DirectEntryMixed', (DirectEntry, DirectGuiMixin), {})
        self.__instructions_entry.set_tooltip(_('The description of the scene'), *tooltip_args)
        self.__pos_mgr['editor_scene_instructions'] = self.__instructions_entry.pos_pixel()
        def load_images_btn(path, col):
            colors = {
                'gray': [
                    (.6, .6, .6, 1),  # ready
                    (1, 1, 1, 1), # press
                    (.8, .8, .8, 1), # rollover
                    (.4, .4, .4, .4)],
                'green': [
                    (.1, .68, .1, 1),
                    (.1, 1, .1, 1),
                    (.1, .84, .1, 1),
                    (.4, .1, .1, .4)]}[col]
            return [self.__load_img_btn(path, col) for col in colors]
        fcols = (.4, .4, .4, .14), (.3, .3, .3, .05)
        b = DirectButton(
            image=load_images_btn('exitRight', 'gray'), scale=.05,
            pos=(.06, 1, .06),
            parent=self._frm, command=self.__on_close, state=NORMAL, relief=FLAT,
            frameColor=fcols[0],
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectButtonMixed', (DirectButton, DirectGuiMixin), {})
        self.__pos_mgr['editor_close'] = b.pos_pixel()
        b.set_tooltip(_('Close the scene editor'), *tooltip_args)
        b = DirectButton(
            image=load_images_btn('save', 'gray'), scale=.05,
            pos=(.06, 1, .18),
            parent=self._frm, command=self.__on_save, state=NORMAL, relief=FLAT,
            frameColor=fcols[0],
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectButtonMixed', (DirectButton, DirectGuiMixin), {})
        self.__pos_mgr['editor_save'] = b.pos_pixel()
        b.set_tooltip(_('Save the scene'), *tooltip_args)
        b = DirectButton(
            image=load_images_btn('menuList', 'gray'), scale=.05,
            pos=(.06, 1, .30),
            parent=self._frm, command=self.__on_scene_list, state=NORMAL, relief=FLAT,
            frameColor=fcols[0],
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectButtonMixed', (DirectButton, DirectGuiMixin), {})
        self.__pos_mgr['editor_sorting'] = b.pos_pixel()
        b.set_tooltip(_('Set the sorting of the scenes'), *tooltip_args)
        # item_modules = glob('pmachines/items/*.py')
        # item_modules = [basename(i)[:-3] for i in item_modules]
        self.__new_items = {}
        # for item_module in item_modules:
        #     mod_name = 'pmachines.items.' + item_module
        #     for member in import_module(mod_name).__dict__.values():
        #         if isclass(member) and issubclass(member, Item) and \
        #                 member != Item:
        #             self.__new_items[member.__name__] = member
        for i in self.__item_classes: self.__new_items[i.__name__] = i
        OnscreenText(
            _('new item'), pos=(.02, .46), parent=self._frm,
            font=self._common['text_font'],
            scale=self._common['scale'],
            fg=self._common['text_fg'],
            align=TextNode.A_left)
        items = list(self.__new_items.keys())
        def new_item_test_set(comps):
            item_labels = [f'new_item_{i.lower()}' for i in items]
            for i in item_labels:
                if i in self.__pos_mgr:
                    del self.__pos_mgr[i]
            for l, b in zip(item_labels, comps):
                b.__class__ = type('DirectFrameMixed', (DirectFrame, DirectGuiMixin), {})
                p = b.pos_pixel()
                self.__pos_mgr[l] = (p[0] + 5, p[1])
        b = DirectOptionMenuTestable(
            scale=.05,
            text=_('new item'), pos=(.02, 1, .4), items=items,
            parent=self._frm, command=self.__on_new_item, state=NORMAL,
            relief=FLAT, item_relief=FLAT,
            frameColor=fcols[0], item_frameColor=fcols[0],
            popupMenu_frameColor=fcols[0],
            popupMarker_frameColor=fcols[0],
            text_font=self._font, text_fg=(.9, .9, .9, 1),
            highlightColor=(.9, .9, .9, .9),
            item_text_font=self._font, item_text_fg=(.9, .9, .9, 1),
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectOptionMenuMixed', (DirectOptionMenu, DirectGuiMixin), {})
        b._show_cb = new_item_test_set
        b.set_tooltip(_('Create a new item'), *tooltip_args)
        self.__pos_mgr['editor_new_item'] = b.pos_pixel()
        b = DirectButton(
            image=load_images_btn('start_items', 'gray'), scale=.05,
            pos=(.06, 1, .58),
            parent=self._frm, command=self.__on_start_items, state=NORMAL, relief=FLAT,
            frameColor=fcols[0],
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectButtonMixed', (DirectButton, DirectGuiMixin), {})
        self.__pos_mgr['editor_start'] = b.pos_pixel()
        b.set_tooltip(_('Initial items'), *tooltip_args)
        b = DirectButton(
            image=load_images_btn('plus', 'gray'), scale=.05,
            pos=(.06, 1, .7),
            parent=self._frm, command=self.__on_new_scene, state=NORMAL, relief=FLAT,
            frameColor=fcols[0],
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        b.__class__ = type('DirectButtonMixed', (DirectButton, DirectGuiMixin), {})
        self.__pos_mgr['editor_new'] = b.pos_pixel()
        b.set_tooltip(_('New scene'), *tooltip_args)
        self.__test_items = []
        self.__set_test_items()
        self.__start_items = self.__scene_list = None
        messenger.send('editor-start')
        self.accept('editor-item-click', self.__on_item_click)
        self.accept('editor-inspector-destroy', self.__on_inspector_destroy)
        self.accept('editor-start-items-save', self.__on_start_items_save)
        self.accept('editor-start-items-destroy', self.__on_start_items_destroy)

    def __set_test_items(self):
        for pixel_space_item in self.__json['test_items']['pixel_space']:
            print(pixel_space_item['id'], pixel_space_item['position'])
            pos_pixel = pixel_space_item['position']
            win_res = base.win.getXSize(), base.win.getYSize()
            pos_win = (pos_pixel[0] / win_res[0] * 2 - 1,
                       1 - pos_pixel[1] / win_res[1] * 2)
            p_from, p_to = Point(pos_win).from_to_points()
            for hit in self.__world.ray_test_all(p_from, p_to).get_hits():
                if hit.get_node() == self.__mouse_plane_node:
                    pos = hit.get_hit_pos()
            self.__set_test_item(pos, pixel_space_item, PixelSpaceTestItem)
        for world_space_item in self.__json['test_items']['world_space']:
            print(world_space_item['id'], world_space_item['position'])
            self.__set_test_item(world_space_item['position'], world_space_item, WorldSpaceTestItem)

    def __set_test_item(self, pos, json, item_class):
        test_item = item_class(
            self.__context.world,
            self.__context.plane_node,
            self.__context.cb_inst,
            self.__context.curr_bottom,
            self.__context.repos,
            json,
            pos=(pos[0], 0, pos[-1]),
            model_scale=.2)
        self.__test_items += [test_item]

    def __on_close(self):
        self.__json['name'] = self.__name_entry.get()
        self.__json['background'] = self.__background_entry.get()
        self.__json['instructions'] = self.__instructions_entry.get()
        if self.__compute_hash() == self.__json['version']:
            self.destroy()
        else:
            self.__dialog = YesNoDialog(dialogName='Unsaved changes',
                                        text=_('You have unsaved changes. Really quit?'),
                                        command=self.__actually_close)
            self.__dialog['frameColor'] = (.4, .4, .4, .14)
            self.__dialog['relief'] = FLAT
            self.__dialog.component('text0')['fg'] = (.9, .9, .9, 1)
            self.__dialog.component('text0')['font'] = self._font
            for b in self.__dialog.buttonList:
                b['frameColor'] = (.4, .4, .4, .14)
                b.component('text0')['fg'] = (.9, .9, .9, 1)
                b.component('text0')['font'] = self._font
                b.component('text1')['fg'] = (.9, .1, .1, 1)
                b.component('text1')['font'] = self._font
                b.component('text2')['fg'] = (.9, .9, .1, 1)
                b.component('text2')['font'] = self._font

    def __on_new_item(self, item):
        info(f'new {item}')
        item_json = {}
        scale = 1
        if item in ['PixelSpaceTestItem', 'WorldSpaceTestItem']:
            scale = .2
        _item = self.__new_items[item](
            self.__context.world,
            self.__context.plane_node,
            self.__context.cb_inst,
            self.__context.curr_bottom,
            self.__context.repos,
            item_json,
            model_scale=scale)
        _item._Item__editing = True
        self.__add_item(_item)
        item_json['class'] = _item.__class__.__name__
        item_json['position'] = list(_item._np.get_pos())
        if item == 'PixelSpaceTestItem':
            del item_json['class']
            self.__json['test_items']['pixel_space'] += [item_json]
        elif item == 'WorldSpaceTestItem':
            del item_json['class']
            self.__json['test_items']['world_space'] += [item_json]
        else:
            self.__json['items'] += [item_json]

    def __actually_close(self, arg):
        if arg:
            self.destroy()
            messenger.send('editor-stop')
        self.__dialog.cleanup()
        self.__dialog = None

    def __on_save(self):
        self.__json['name'] = self.__name_entry.get()
        self.__json['background'] = self.__background_entry.get()
        self.__json['instructions'] = self.__instructions_entry.get()
        self.__json['version'] = self.__compute_hash()
        json_name = self.__filenamename_entry.get()
        with open('assets/scenes/%s.json' % json_name, 'w') as f:
            f.write(dumps(self.__json, indent=2, sort_keys=True))

    def __on_scene_list(self):
        self.__scene_list = SceneList(self.__pos_mgr)

    def __load_img_btn(self, path, col):
        img = OnscreenImage('assets/images/buttons/%s.dds' % path)
        img.set_transparency(True)
        img.set_color(col)
        img.detach_node()
        return img

    def __compute_hash(self):
        new_dict = deepcopy(self.__json)
        del new_dict['version']
        new_dict_str = str(dumps(new_dict, indent=2, sort_keys=True))
        h = hashlib.new('sha256')
        h.update(new_dict_str.encode())
        return h.hexdigest()[:12]

    def __on_item_click(self, item):
        if self.__inspector and self.__inspector.item == item: return
        if self.__inspector:
            self.__inspector.destroy()
        if item.__class__ == PixelSpaceTestItem:
            self.__inspector = PixelSpaceInspector(item, self.__items)
        elif item.__class__ == WorldSpaceTestItem:
            self.__inspector = WorldSpaceInspector(item, self.__items, self.__pos_mgr)
        else:
            self.__inspector = Inspector(item, self.__items, self.__pos_mgr, self.__item_strategy_classes)

    def __on_inspector_destroy(self):
        self.__inspector = None

    def __on_new_scene(self):
        self.destroy()
        messenger.send('editor-stop')
        messenger.send('new_scene')

    def __on_start_items(self):
        self.__start_items = StartItems(self.__json['start_items'], self.__pos_mgr, self.__item_classes, self.__item_strategy_classes)

    def __on_start_items_save(self, start_items):
        self.__json['start_items'] = start_items
        self.__on_save()

    def __on_start_items_destroy(self):
        self.__start_items = None

    @property
    def test_items(self):
        return self.__test_items

    def destroy(self):
        self._frm.destroy()
        if self.__inspector:
            self.__inspector.destroy()
        self.ignore('editor-item-click')
        self.ignore('editor-inspector-destroy')
        self.ignore('editor-start-items-save')
        self.ignore('editor-start-items-destroy')
        if self.__dialog: self.__actually_close(False)
        for t in self.__test_items: t.destroy()
        self.__test_items = []
        if self.__start_items:
            self.__start_items.destroy()
        if self.__scene_list:
            self.__scene_list.destroy()