pyscratch-pysc 1.0.3__py3-none-any.whl

pyscratch/tools/sprite_preview/left_panel/frame_preview_card.py

@@ -0,0 +1,238 @@
+"""
+broadcast messages: 
+    order_change ((old, new))
+    preview_click(dict(surface=surface, order=order))
+    change_animation_done (frames: List)
+
+    
+receice messages:
+    change_animation
+        reload the animation from the animation path
+        remove and create the frame cards for this animation
+
+shared_data:
+    scrolling_offset (read only)
+    animation_path 
+    frame_card_list 
+"""
+
+from typing import Dict, List
+
+import numpy as np
+import pyscratch as pysc
+from pyscratch.sprite import Sprite
+from settings import *
+from pygame import Surface
+from math import floor
+from pathlib import Path
+
+
+# Sprite Function: the frame preview card
+FRAME_PREVIEW_MARGIN = 10
+preview_width = LEFT_PANEL_WIDTH-FRAME_PREVIEW_MARGIN*2
+preview_height = preview_width 
+
+def FramePreviewCard(surface:Surface, order):
+
+    preview_bg = pysc.create_rect_sprite(
+        (255, 255, 255),
+        preview_width, 
+        preview_height
+    )
+    preview_bg['surface'] = surface
+    preview_bg['order'] = order
+    preview_bg.oob_limit = np.inf
+    
+    preview_bg.set_draggable(True)
+    
+
+    # set xy
+    ypos = FRAME_PREVIEW_MARGIN + order*(preview_height+FRAME_PREVIEW_MARGIN) + preview_height/2
+    
+    xpos = LEFT_PANEL_WIDTH/2
+    preview_bg.set_xy((xpos, ypos))
+    preview_bg.y += pysc.game['scrolling_offset']
+
+    # display preview
+    image_margin = 20
+    fit = "horizontal" if surface.get_width() >= surface.get_height() else "vertical"
+    pv_surface = pysc.scale_to_fit_aspect(surface, (preview_width-image_margin, preview_height-image_margin ), fit)
+    preview_bg.draw(pv_surface, (preview_width/2, preview_height/2))
+    
+
+    # send message on click
+    def on_click():
+
+
+        pysc.game.broadcast_message('preview_click', dict(surface=surface, order=order))
+        pysc.game.broadcast_message('show_bin', None)
+
+
+    preview_bg.when_this_sprite_clicked().add_handler(on_click)
+
+
+    # scrolling
+    def on_scrolling(offset):
+        preview_bg.y = ypos + offset
+    preview_bg.when_receive_message('scrolling').add_handler(on_scrolling)
+
+
+        
+
+    # dragging
+    def on_mouse_release():
+        pysc.game.broadcast_message('hide_bin', None)
+        
+        left_panel: pysc.Sprite = pysc.game['left_panel']  
+
+        frame_card_list = pysc.game['frame_card_list']
+
+
+
+        new_order = ((preview_bg.y-pysc.game['scrolling_offset'])-preview_height/2-FRAME_PREVIEW_MARGIN)/(preview_height+FRAME_PREVIEW_MARGIN)        
+        new_order = floor(new_order+0.5)
+
+
+        preview_bg.x = xpos
+
+        preview_bg.y = ypos + pysc.game['scrolling_offset']
+
+        new_order = min(max(new_order, 0), len(frame_card_list)-1) 
+
+        if not (to_remove := pysc.game['frame_bin'].is_touching_mouse()):
+            if not left_panel.is_touching(preview_bg): return
+            if new_order == order: return 
+            
+
+        print(f"{order} -> {new_order}")
+
+        first_half = frame_card_list[:order]
+        second_half = frame_card_list[order+1:] if (order+1)<len(frame_card_list) else []
+
+        temp = first_half + second_half
+
+        #print([c['order'] for c in temp] )
+
+        if not to_remove: 
+            temp = temp[:new_order] + [preview_bg] + (temp[new_order:] if (new_order)<len(temp) else [])
+
+        #print([c['order'] for c in temp] )
+
+        write_new_frame_list([f['surface'] for f in temp])
+
+        # update 
+        pysc.game.broadcast_message('change_animation', pysc.game['animation_path'])
+            
+    pysc.game.when_this_sprite_click_released(preview_bg).add_handler(on_mouse_release)
+
+    return preview_bg
+
+
+def on_cut_sprite_frame_drop(data):
+    if not 'animation_path' in pysc.game.shared_data:
+        pysc.game.broadcast_message('warning', "Animation not selected yet.")
+        return
+
+
+
+    sprite: pysc.Sprite = data['sprite']
+    surface: Surface = data['surface']
+    mos_x, mos_y = data['position']
+    frame_card_list = pysc.game['frame_card_list']
+
+
+    left_panel: pysc.Sprite = pysc.game['left_panel']  
+    
+    if not left_panel.is_touching_mouse(): return
+
+    
+
+    order = ((mos_y-pysc.game['scrolling_offset'])-preview_height/2-FRAME_PREVIEW_MARGIN)/(preview_height+FRAME_PREVIEW_MARGIN)        
+    order = floor(order+0.5)
+
+
+
+    frame_card_list = pysc.game['frame_card_list']
+
+    first_half = frame_card_list[:order]
+    second_half = frame_card_list[order:] if (order)<len(frame_card_list) else []
+
+    frame_list = [f['surface'] for f in first_half] +[surface]+ [f['surface'] for f in second_half]
+
+    write_new_frame_list(frame_list)
+
+    # update 
+    pysc.game.broadcast_message('change_animation', pysc.game['animation_path'])
+
+    sprite.x = sprite['x']
+    sprite.y = sprite['y']
+
+
+pysc.game.when_receive_message('cut_sprite_frame_drop').add_handler(on_cut_sprite_frame_drop)
+
+
+
+
+# helper function
+import shutil
+def write_new_frame_list(frame_list: List[Surface]):
+    # TODO: frame quality degrade over time?
+    temp_folder = Path('temp')
+    temp_folder.mkdir(exist_ok=True)
+    shutil.rmtree(temp_folder)
+    temp_folder.mkdir()
+
+    suffix = 'png' # TODO: allow changing suffix 
+    for i, f in enumerate(frame_list):
+        pygame.image.save(f, temp_folder/f"{i}.{suffix}")
+
+    shutil.rmtree(pysc.game['animation_path'])
+    shutil.copytree(temp_folder, pysc.game['animation_path'])
+    shutil.rmtree(temp_folder)
+    
+
+
+# event: when there is a change to the animation
+# reload the animation from the animation path
+pysc.game['frame_card_list'] = []
+def on_change_animation(path: Path):
+
+    #pysc.game['scrolling_offset'] = 0
+
+
+
+    pysc.game['animation_path'] = path
+    for c in pysc.game['frame_card_list']:
+        c.remove()
+    pysc.game['frame_card_list'] = []
+
+    def extract_images(path: Path):
+        index2image: Dict[int, pygame.Surface] = {}
+
+        for f in path.iterdir():
+            if f.is_dir():
+                continue
+
+            if not f.stem.isdigit(): 
+                print(f'skipping: {f.name}')
+                continue
+            index2image[int(f.stem)] = pygame.image.load(f).convert_alpha()
+        
+        return [index2image[i] for i in sorted(index2image.keys())]
+        
+    try: 
+        frames = extract_images(path)
+    except:
+        print('invalid folder structure.')
+        return 
+    
+
+    for i, f in enumerate(frames):
+        pysc.game.shared_data['frame_card_list'].append(
+            FramePreviewCard(f, i)
+        )
+        
+    pysc.game.broadcast_message("change_animation_done", frames)
+            
+    
+pysc.game.when_receive_message('change_animation').add_handler(on_change_animation)

pyscratch/tools/sprite_preview/left_panel/frame_preview_panel.py

@@ -0,0 +1,42 @@
+"""
+broadcast messages: 
+    scrolling (scrolling_offset)
+
+shared_data:
+    scrolling_offset
+"""
+
+
+from pathlib import Path
+from typing import Dict
+
+from pygame import Surface
+import pyscratch as pysc
+from settings import *
+
+
+
+# Sprite: the panel (the background of the preview frames)
+PANEL_BG_COLOUR = 199, 207, 224
+panel = pysc.create_rect_sprite(
+    PANEL_BG_COLOUR,
+    LEFT_PANEL_WIDTH, 
+    SCREEN_HEIGHT# - PANEL_MARGIN*2
+)
+panel.set_xy((LEFT_PANEL_WIDTH/2,  SCREEN_HEIGHT/2))
+
+# event: scrolling
+pysc.game['scrolling_offset'] = 0
+def on_mouse_scroll(updown):
+    if not panel.is_touching_mouse(): return
+    if updown == 'up':
+        pysc.game['scrolling_offset'] += 10
+    else: 
+
+        pysc.game['scrolling_offset'] -= 10
+        
+    pysc.game.broadcast_message("scrolling", pysc.game['scrolling_offset'])
+    
+pysc.game.when_mouse_scroll().add_handler(on_mouse_scroll)
+pysc.game['left_panel'] = panel
+

pyscratch/tools/sprite_preview/main.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import pyscratch as pysc
+from settings import *
+
+from right_panel import file_display_area, spritesheet_view, cut_parameters, back_button, cut_button, ss_select_corner, cut_parameter_fitting
+from main_panel import sprite_edit_ui, play_edit_ui, animation_display, frame_bin, set_as_sprite_folder, warning_message
+from left_panel import frame_preview_card, frame_preview_panel
+
+bg = pysc.create_rect((221, 221, 221), SCREEN_WIDTH, SCREEN_HEIGHT)
+pysc.game.update_screen_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pysc.game.set_backdrops([bg])
+pysc.game.switch_backdrop(0)
+
+pysc.game.broadcast_message('folder_update', Path('assets'))
+pysc.game.broadcast_message('cut_or_nav_mode_change', 'nav')
+#pysc.game.broadcast_message('change_sprite_selection', Path('./testing_assets/cat'))
+
+pysc.game.start(30)

pyscratch/tools/sprite_preview/main_panel/animation_display.py

@@ -0,0 +1,77 @@
+"""
+shared_data:
+    display_sprite
+    scale_factor
+    frame_interval
+    is_playing
+
+receive messages:
+    preview_click
+        change the frame of the display sprite when the preview is clicked
+
+    scale_factor_change
+        change the scale of the display sprite    
+    
+    change_animation_done
+        destory and create the display sprite for a new animation
+"""
+
+from pathlib import Path
+from typing import Dict
+
+from pygame import Surface
+import pyscratch as pysc
+from settings import *
+
+
+pysc.game['display_sprite'] = None
+
+
+def create_display_sprite(frames):
+
+    #frame_list = [c['surface'] for c in pysc.game['frame_card_list']]
+    #print(frames)
+    if display_sprite:=pysc.game['display_sprite']:
+        display_sprite.remove()
+        x, y = display_sprite.x, display_sprite.y
+    else:
+        x, y = 350, 200
+
+    if not len(frames):
+        pysc.game['display_sprite'] = None
+        return
+
+
+    sprite = pysc.Sprite({'always':frames})
+    sprite.set_xy((x, y))
+    
+    sprite.set_draggable(True)
+
+    if pysc.game['scale_factor']:
+        sprite.set_scale(pysc.game['scale_factor'])
+
+    pysc.game['display_sprite'] = sprite
+
+    def play(_):
+        #TODO: if the user put a big value in frame_interval, and change it back to a small one
+        # the animation will wait for the big frame_interval until it comes back again 
+        while True:
+            itv = pysc.game['frame_interval']
+            if pysc.game['is_playing'] and itv:
+                sprite.next_frame()
+            yield itv if itv else 0.1
+
+    sprite.when_timer_above(0).add_handler(play)
+
+
+    def on_scale_factor_change(scale):
+        print(scale)
+        if scale: 
+            sprite.set_scale(scale)
+
+    sprite.when_receive_message("scale_factor_change").add_handler(on_scale_factor_change)
+    sprite.when_receive_message('preview_click').add_handler(lambda d: sprite.set_frame(d['order']))
+
+
+
+pysc.game.when_receive_message("change_animation_done").add_handler(create_display_sprite)

pyscratch/tools/sprite_preview/main_panel/frame_bin.py

@@ -0,0 +1,33 @@
+"""
+msg in:
+    show_bin
+    hide_bin
+
+shared data
+    frame_bin
+"""
+
+
+import pyscratch as pysc
+from settings import *
+
+
+frame_bin = pysc.create_rect_sprite((255, 127, 127), 100, 100)
+frame_bin.write_text("bin", DEFAULT_FONT48, offset=(50, 50))
+
+def set_xy():
+    
+    container = pysc.game['main_bottom_panel']
+
+    frame_bin.hide()
+    frame_bin.lock_to(container, (0,0))
+    frame_bin.x = 0
+    frame_bin.y = 0
+    
+frame_bin.when_game_start().add_handler(set_xy)
+
+
+frame_bin.when_receive_message('show_bin').add_handler(lambda d: frame_bin.show())
+frame_bin.when_receive_message('hide_bin').add_handler(lambda d: frame_bin.hide())
+
+pysc.game['frame_bin'] = frame_bin

pyscratch/tools/sprite_preview/main_panel/play_edit_ui.py

@@ -0,0 +1,64 @@
+from utils.input_box import IntegerInputBox, FloatInputBoxVerticallyLabel
+import pyscratch as pysc
+from settings import *
+frame_itv = FloatInputBoxVerticallyLabel("frame_interval", default_value="0.2")
+
+def set_xy():
+    container = pysc.game['main_bottom_panel']
+    frame_itv.lock_to(container, (0,0))
+    frame_itv.set_xy((200, 30))
+    
+frame_itv.when_game_start().add_handler(
+    set_xy
+)
+
+def new_switch(text0, text1, data_key):
+    container = pysc.game.shared_data['main_bottom_panel']
+    container_width, container_height = pysc.game.shared_data['main_bottom_size']
+
+    button_w, button_h = 80, 50
+    button = pysc.create_rect_sprite((221, 221, 221), button_w, button_h)
+    
+    pysc.game.shared_data[data_key] = False
+    button.write_text(text0, DEFAULT_FONT48, colour=(0,0,0), offset=(button_w/2, button_h/2))
+
+    def on_click():
+        pysc.game.shared_data[data_key] = not pysc.game.shared_data[data_key]
+
+        if pysc.game.shared_data[data_key]:
+            button.write_text(text1, DEFAULT_FONT48, colour=(0,0,0), offset=(button_w/2, button_h/2))
+        else:
+            button.write_text(text0, DEFAULT_FONT48, colour=(0,0,0), offset=(button_w/2, button_h/2))
+    
+    button.when_this_sprite_clicked().add_handler(on_click)
+
+
+    button.lock_to(container, (-(container_width-button_w)/2, -(container_height-button_h)/2), reset_xy=True)
+    return button
+
+
+def create_play_button():
+    container = pysc.game.shared_data['main_bottom_panel']
+
+    play_button = new_switch('Play','Pause', 'is_playing')
+    play_button.lock_to(container, (0,0))
+    
+    play_button.set_xy((0, 70))
+
+pysc.game.when_game_start().add_handler(create_play_button)
+
+
+
+
+
+scale_factor_input = FloatInputBoxVerticallyLabel("scale_factor", "scale_factor_change", default_value="1")
+
+def set_xy2():
+    container = pysc.game.shared_data['main_bottom_panel']
+    scale_factor_input.lock_to(container, (0,0))
+    scale_factor_input.set_xy((200, 120))
+    
+scale_factor_input.when_game_start().add_handler(
+    set_xy2
+)
+

pyscratch/tools/sprite_preview/main_panel/set_as_sprite_folder.py

@@ -0,0 +1,22 @@
+from utils.input_box import IntegerInputBox, FloatInputBoxVerticallyLabel
+import pyscratch as pysc
+from settings import *
+
+button = pysc.create_rect_sprite((150, 150, 150), 220, 50)
+button.write_text('Set current folder as sprite', DEFAULT_FONT24, offset=(110, 25))
+
+def set_xy():
+    container = pysc.game['main_bottom_panel']
+    button.lock_to(container, (0,0))
+    button.x = 0
+    button.y = 0
+    
+button.when_game_start().add_handler(set_xy)
+
+
+def on_click():
+    pysc.game.broadcast_message('change_sprite_selection', pysc.game['path'])
+    pass
+
+
+button.when_this_sprite_clicked().add_handler(on_click)

pyscratch/tools/sprite_preview/main_panel/sprite_edit_ui.py

@@ -0,0 +1,174 @@
+"""
+shared_data
+    animation_dict (order -> animation selection button)
+    sprite_folder_path
+    path (read): navigation path
+    main_bottom_size (read)
+    main_bottom_panel (read)
+
+broadcast messages:
+    folder_update (navigation path)
+    change_sprite_selection (path of the sprite folder)
+    change_animation (path of the animation folder)
+
+
+receive messages:
+    change_sprite_selection
+        change the animation panel when another sprite is selected
+"""
+
+
+from pathlib import Path
+from typing import cast
+import pyscratch as pysc
+from settings import *
+
+container_width = SCREEN_WIDTH - LEFT_PANEL_WIDTH - RIGHT_PANEL_WIDTH - PANEL_MARGIN*3
+container_height = 300
+
+# container
+container = pysc.create_rect_sprite((230, 230, 230), container_width, container_height)
+container.x = container_width/2+LEFT_PANEL_WIDTH+PANEL_MARGIN
+container.y = SCREEN_HEIGHT-container_height/2-PANEL_MARGIN
+pysc.game['main_bottom_panel'] = container
+pysc.game['main_bottom_size'] = container_width, container_height
+
+# sprite function
+def NewButton(text):
+    button_w, button_h = 150, 50
+    button = pysc.create_rect_sprite((221, 221, 221), button_w, button_h)
+    button.write_text(text, DEFAULT_FONT48, colour=(0,0,0), offset=(button_w/2, button_h/2))
+    button.lock_to(container, (-(container_width-button_w)/2, -(container_height-button_h)/2), reset_xy=True)
+    return button
+
+
+# sprite: add sprite button
+add_sprite_button = NewButton("New Sprite")
+add_sprite_button.y=10
+add_sprite_button.x=200
+
+# event: the click of the add sprite button
+def on_click1():
+    folder_path: Path = pysc.game.shared_data['path']
+    
+    c = 0
+    while True:
+        
+        new_folder = (folder_path / f"unnamed_sprite_{c}")
+        if not new_folder.exists():
+            new_folder.mkdir()
+            break
+        else:
+            c+=1
+    pysc.game.broadcast_message('folder_update', folder_path)
+    pysc.game.broadcast_message('cut_or_nav_mode_change', 'nav')
+    pysc.game.broadcast_message('change_sprite_selection', new_folder)
+        
+add_sprite_button.when_this_sprite_clicked().add_handler(on_click1)
+
+
+# sprite function: animation selection
+def AnimationSelection(order, path):
+    
+
+    w, h = 120, 30
+    on_select = pysc.create_rect((150,150, 150), w, h)
+    not_on_select = pysc.create_rect((127, 127, 127), w, h)
+    sprite = pysc.Sprite(dict(on_select=[on_select], not_on_select=[not_on_select]))
+
+    sprite.lock_to(container, (-(container_width-w)/2, -(container_height-h)/2))
+    sprite.x = 3
+    sprite.y = order*(h+3)+3
+
+    sprite.set_animation('on_select')
+    sprite.write_text(path.stem, DEFAULT_FONT24, offset=(w/2, h/2))
+
+    sprite.set_animation('not_on_select')
+    sprite.write_text(path.stem, DEFAULT_FONT24, offset=(w/2, h/2))
+
+
+
+    def on_click():
+        sprite.set_animation('on_select')
+
+        pysc.game.broadcast_message('change_animation', path)
+        pysc.game.broadcast_message('deselect', sprite)
+
+
+    sprite.when_this_sprite_clicked().add_handler(on_click)
+
+
+    def on_deselect(s):
+        if not sprite is s:
+            sprite.set_animation('not_on_select')
+
+    sprite.when_receive_message('deselect').add_handler(on_deselect)
+
+    return sprite
+
+# event: msg: change_sprite_selection: 
+# remove and create the animation buttons when sprite change
+pysc.game['animation_dict'] = {}
+def on_msg_change_sprite_selection(sprite_folder:Path):
+    """
+    change the animation selection buttons
+    """
+
+    pysc.game['sprite_folder_path'] = sprite_folder
+
+    #pysc.game['frame_dict'] = 
+
+
+
+    # remove all the old buttons
+    for k, v in pysc.game['animation_dict'].items():
+        v.remove()
+    pysc.game['animation_dict'] = {}
+
+    animation_dict = pysc.game['animation_dict']
+    
+
+    # add the new buttons
+    c = 0
+    for f in sprite_folder.iterdir():
+        if f.is_dir():
+            animation_dict[c] = AnimationSelection(c, f)
+            c+=1
+
+pysc.game.when_receive_message("change_sprite_selection").add_handler(on_msg_change_sprite_selection)
+
+
+
+
+# sprite: add animation button
+add_animation_button = NewButton("New Animation")
+add_animation_button.x = 370
+add_animation_button.y = 10
+
+# event: click of the add animation button  
+def on_click2():
+
+
+    if not (folder_path:= pysc.game.shared_data.get('sprite_folder_path')):
+        pysc.game.broadcast_message('warning', "Sprite folder not selected yet")
+        return
+    
+    folder_path = cast(Path, folder_path)
+    c = 0
+    while True:
+        
+        
+        new_folder = (folder_path / f"animation_{c}")
+        if not new_folder.exists():
+            new_folder.mkdir()
+            break
+        else:
+            c+=1
+
+    pysc.game.broadcast_message('folder_update', pysc.game.shared_data['path'])
+    
+    # no actual change. just to trigger the update
+    pysc.game.broadcast_message('change_sprite_selection', folder_path)
+
+        
+add_animation_button.when_this_sprite_clicked().add_handler(on_click2)

pyscratch/tools/sprite_preview/main_panel/warning_message.py

@@ -0,0 +1,25 @@
+from utils.render_wrapped_file_name import render_wrapped_file_name
+import pyscratch as pysc
+from settings import *
+
+w, h = 400, 100
+message_display = pysc.create_rect_sprite((255, 255, 255), w, h)
+message_display.hide()
+ori_xy = 200, 200
+message_display.set_draggable(True)
+
+def on_warning_message(message):
+
+    message_display.show()
+    message_display.set_xy(ori_xy)
+    txt = render_wrapped_file_name(message, 200, DEFAULT_FONT24, color=(255,0,0))
+    message_display.draw(txt, offset=(w/2, h/2))
+
+
+
+message_display.when_receive_message('warning').add_handler(on_warning_message)
+
+def on_click():
+    message_display.hide()
+
+message_display.when_this_sprite_clicked().add_handler(on_click)