pyscratch-pysc 1.0.3__py3-none-any.whl

examples/getting-started/step 9 - messages/enemy.py

@@ -0,0 +1,98 @@
+import pyscratch as pysc
+
+
+# create the sprite and initial settings
+enemy = pysc.create_animated_sprite("assets/other_fishes")
+
+
+def enemy_on_game_start():
+    enemy.set_rotation_style_left_right()
+    
+    # hide the parent
+    enemy.hide() 
+    
+    # the clone appear in the same location as the parent very briefly
+    # when it's created before we set it to a random location. 
+    enemy.set_xy((-200, -200))  
+
+    # clone itself very 2 seconds
+    while True: 
+        enemy.create_clone()
+        yield 2
+
+enemy.when_game_start().add_handler(enemy_on_game_start)
+
+
+# clone movement
+#def on_clone(clone_sprite): 
+def on_clone(clone_sprite: pysc.Sprite): 
+
+
+    # random height
+    clone_sprite.y = pysc.random_number(0, 720)
+
+    # randomly either from the left or from the right
+    if pysc.random_number(0, 1) > 0.5: 
+        clone_sprite.x = 0
+        clone_sprite.direction = 0 # left to right
+    else:
+        clone_sprite.x = 1280
+        clone_sprite.direction = 180 # right to left
+
+    # random size
+    size = pysc.random_number(0.3, 2)
+    clone_sprite.set_scale(size)
+    clone_sprite['size'] = size
+
+    # show the sprite
+    clone_sprite.show()
+    
+
+    #player = pysc.game['player']
+    player: pysc.Sprite = pysc.game['player']
+    
+    # movement
+    while True:
+
+
+        if player.sprite_data['size'] > size:
+            clone_sprite.set_frame(1)
+        else:
+            clone_sprite.set_frame(0)
+
+            
+        if clone_sprite.distance_to_sprite(player) < 200:
+            clone_sprite.point_towards_sprite(player)
+
+            if player['size'] > size:
+                clone_sprite.direction += 180
+
+        
+
+        clone_sprite.direction += pysc.random_number(-2, 2)
+
+        clone_sprite.move_indir(2/size)
+        yield 1/60
+
+enemy.when_started_as_clone().add_handler(on_clone)
+
+
+# clone touch the player 
+#def clone_touch_the_player(clone_sprite):
+def clone_touch_the_player(clone_sprite: pysc.Sprite):
+
+    player: pysc.Sprite = pysc.game['player']
+    while True:
+        if clone_sprite.is_touching(player):
+            clone_sprite.remove()
+
+            if player['size'] > clone_sprite['size']:
+                pysc.game.broadcast_message('size_change', 0.2)
+            else:
+                pysc.game.broadcast_message('size_change', -0.2)
+                pysc.game['health'] -= 1
+            
+
+        yield 1/pysc.game['framerate']
+    
+enemy.when_started_as_clone().add_handler(clone_touch_the_player)

examples/getting-started/step 9 - messages/hearts.py

@@ -0,0 +1,39 @@
+import pyscratch as pysc
+
+# create the sprites
+heart1 = pysc.create_animated_sprite("assets/hearts")
+heart2 = pysc.create_animated_sprite("assets/hearts")
+heart3 = pysc.create_animated_sprite("assets/hearts")
+
+# variable definitons should be done outside the event to guarantee the variables is defined before any event try to access it 
+pysc.game['health'] = 3
+
+def heart_display():
+
+    heart1.set_xy((100, 100))
+    heart1.set_scale(3)
+
+    heart2.set_xy((155, 100))
+    heart2.set_scale(3)
+
+    heart3.set_xy((210, 100))
+    heart3.set_scale(3)
+
+
+    while True: 
+        if pysc.game['health'] < 3:
+            heart3.set_frame(1)
+
+        if pysc.game['health'] < 2:
+            heart2.set_frame(1)
+
+        if pysc.game['health'] < 1:
+            heart1.set_frame(1)
+        
+        yield 1/pysc.game['framerate']
+    
+# ideally, you should do
+# `pysc.game.when_game_start([heart1, heart2, heart3])`, so when any of the hearts is removed, the event is removed as well. 
+# but we aren't going to remove any of the hearts, so there's no need to do so there. 
+
+pysc.game.when_game_start().add_handler(heart_display)

examples/getting-started/step 9 - messages/main.py

@@ -0,0 +1,23 @@
+from numpy import deg2rad
+import pyscratch as pysc
+import player, enemy, hearts
+
+# backdrop
+backdrop_img = pysc.load_image('assets/my_background.jpg') # load the image(s)
+pysc.game.set_backdrops([backdrop_img]) # a list of all the backdrop images 
+pysc.game.switch_backdrop(0) # use the backdrop at index 0 
+
+
+# start the game
+screen_height = 720
+screen_width = 1280
+framerate = 60
+
+# add these to as shared variables so other sprites might use it
+pysc.game['screen_height'] = screen_height
+pysc.game['screen_width'] = screen_width
+pysc.game['framerate'] = framerate
+
+pysc.game.update_screen_mode((screen_width, screen_height))
+pysc.game.start(framerate)
+

examples/getting-started/step 9 - messages/player.py

@@ -0,0 +1,78 @@
+import pyscratch as pysc
+
+
+player = pysc.create_single_costume_sprite("assets/player-fish.png")
+pysc.game['player'] = player  # add the player as a shared variable so other sprites can access it
+
+player['size'] = 1  
+
+def on_game_start():
+
+    player.set_rotation_style_left_right()
+    speed_decay = 0.9
+    speed_y = 0
+    speed_x = 0
+
+    while True:
+
+        player.set_scale(player['size'])
+
+        max_speed = 4/player['size']
+
+
+        if pysc.is_key_pressed('w'):
+            speed_y = -max_speed
+
+        elif pysc.is_key_pressed('s'):
+            speed_y = max_speed
+
+        else:
+            speed_y *= speed_decay # speed_y = speed_y * speed_decay
+
+        if pysc.is_key_pressed('a'):
+            player.direction = 180
+            speed_x = -max_speed
+            
+        elif pysc.is_key_pressed('d'):
+            player.direction = 0
+            speed_x = max_speed
+        else:
+            speed_x *= speed_decay # speed_x = speed_y * speed_decay
+
+
+        player.y += speed_y
+        player.x += speed_x
+
+        yield 1/60
+
+
+game_start_event = player.when_game_start()
+game_start_event.add_handler(on_game_start)
+
+# or shorter: player.when_game_start().add_handler(on_game_start)
+
+
+def check_health():
+
+    while True:
+        if not pysc.game['health']:
+            player.remove()
+        yield 1/60
+
+
+game_start_event.add_handler(check_health)
+
+
+
+def on_size_change(change):
+
+
+    each_step = change/10
+
+    for i in range(10):
+        player['size'] += each_step
+
+        yield 0.1
+
+player.when_receive_message('size_change').add_handler(on_size_change)
+    

examples/perspective_background/main.py

@@ -0,0 +1,14 @@
+import pyscratch as pysc
+from pyscratch import game
+import  trees, player
+
+sur = pysc.create_rect((169,234,126), 1280, 720)
+sur_sky = pysc.create_rect((196,241,255), 1280, 200)
+sur.blit(sur_sky, (0,0))
+
+game.set_backdrops([sur])
+game.switch_backdrop(0)
+
+game.start(show_mouse_position=True, use_frame_time=True)
+game.save_sprite_states()
+

examples/perspective_background/player.py

@@ -0,0 +1,52 @@
+import pyscratch as pysc
+from pyscratch import game
+
+
+sp = pysc.create_animated_sprite("assets/used_by_examples/perspective_background/the_red_guy_piskel")  
+
+def next_frame():
+    while True:
+        yield 0.2
+        sp.next_frame()
+sp.when_game_start().add_handler(next_frame)
+
+def on_game_start():
+    sp.x = 1280/2
+    sp.y = 720/2
+    sp.retrieve_saved_state()
+    sp.set_scale(3)
+    sp.set_draggable(True)
+
+    sp.set_rotation_style_left_right()
+    while True:
+    
+        yield 1/game.framerate
+
+        is_running = False
+        if pysc.is_key_pressed('d'):
+            game['centre_x'] += 5
+            is_running = True
+            sp.direction=0
+            
+        if pysc.is_key_pressed('a'):
+            game['centre_x'] -= 5
+            is_running = True
+            sp.direction=180
+
+        if pysc.is_key_pressed('w'):
+            game['centre_d'] += 5
+            is_running = True
+            
+
+        if pysc.is_key_pressed('s'):
+            game['centre_d'] -= 5
+            is_running = True
+        
+        if is_running:
+            sp.set_animation('run')
+        else:
+            sp.set_animation('idle')
+
+        
+            
+sp.when_game_start().add_handler(on_game_start)

examples/perspective_background/trees.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pyscratch as pysc
+from pyscratch import game
+
+game['centre_x'] = 1280/2
+game['centre_h'] = 300
+game['centre_d'] = 0
+def tree_L():
+    sp = pysc.create_animated_sprite("assets/used_by_examples/perspective_background/tree_L")  
+    sp['d'] = pysc.random_number(100, 2000) 
+    sp['world_x'] = pysc.random_number(0, 1000)
+    sp.oob_limit=np.inf
+    def on_game_start():
+        sp.set_frame(int(pysc.random_number(0, 2.99)))
+        sp.set_draggable(True)
+        d = sp['d']-game['centre_d']
+        game.change_layer(sp, 1000-int(sp['d']))
+        while True:
+            yield 1/game.framerate
+            d = sp['d']-game['centre_d']
+
+            new_scale = pysc.cap(300/d, 0.1, 3)
+            if new_scale == 3:
+                sp.hide()
+            else:
+                sp.show()
+                sp.set_scale(new_scale)
+            if d <= 0:
+                sp.hide()
+
+            sp.y = -200+game.screen_height-np.arctan(d/game['centre_h'])/np.pi*game.screen_height 
+            sp.x = ((sp['world_x']-game['centre_x'])/d + 0.5)*game.screen_width
+
+    sp.when_game_start().add_handler(on_game_start)
+
+    return sp
+
+for i in range(50):
+    tree_L()

examples/simple_pong/ball.py

@@ -0,0 +1,72 @@
+from numpy import True_
+import pyscratch as pysc
+from pyscratch import game
+
+SCREEN_HEIGHT = 720
+SCREEN_WIDTH = 1280
+
+# TODO: recommend a colour picking website
+ball_colour = (220, 220, 220)
+ball_radius = 25
+ball_sprite = pysc.create_circle_sprite(ball_colour, ball_radius, position = (SCREEN_WIDTH//2, SCREEN_HEIGHT//2))
+game['ball_sprite'] = ball_sprite
+
+top_edge, left_edge, bottom_edge, right_edge = pysc.create_edge_sprites(thickness=0)
+
+ 
+def movement():
+    speed_x = 3
+    speed_y = 3
+    pong = False
+
+    while True: 
+        yield .5/game.framerate # wait for half a frame (for smoothness)
+        
+
+        if game['running']:
+            
+            ball_sprite.show()
+            if ball_sprite.is_touching(top_edge):
+                pong = True
+                speed_y = abs(speed_y)
+
+            elif ball_sprite.is_touching(bottom_edge):
+                pong = True
+                speed_y = -abs(speed_y)
+
+            elif ball_sprite.is_touching(left_edge):
+                speed_x = abs(speed_x)
+                ball_sprite.broadcast_message('right_score')
+                game['running'] = False
+                pong = False
+
+            elif ball_sprite.is_touching(right_edge):
+                speed_x = -abs(speed_x)
+                ball_sprite.broadcast_message('left_score')
+                game['running'] = False
+                pong = False
+
+            elif ball_sprite.is_touching(game['right_paddle']):
+                pong = True
+                speed_x = -abs(speed_x)
+
+            elif ball_sprite.is_touching(game['left_paddle']):
+                pong = True
+                speed_x = abs(speed_x)
+
+            elif pong:
+                game.play_sound('pong')
+                pong = False
+
+                
+            ball_sprite.x += speed_x
+            ball_sprite.y += speed_y
+        else:
+            ball_sprite.hide()
+            
+            ball_sprite.y = SCREEN_HEIGHT//2
+            ball_sprite.x = SCREEN_WIDTH//2
+    
+game_start_event = ball_sprite.when_game_start()
+game_start_event.add_handler(movement)
+

examples/simple_pong/left_paddle.py

@@ -0,0 +1,36 @@
+import pyscratch as pysc
+from pyscratch import game
+
+SCREEN_HEIGHT = 720
+SCREEN_WIDTH = 1280
+
+paddle_colour = (200, 200, 200)
+paddle_width = 20
+paddle_height = 130
+paddle_margin = 30
+
+
+sprite = pysc.create_rect_sprite(paddle_colour, paddle_width, paddle_height,  position=(paddle_margin, SCREEN_HEIGHT//2))
+game['left_paddle'] = sprite
+sprite.set_draggable(True)
+
+def movement():
+    speed = 0
+    while True: 
+        if pysc.is_key_pressed('w'):
+            speed = -8
+        if pysc.is_key_pressed('s'):
+            speed = 8
+        
+        speed *= 0.9
+
+        sprite.y += speed
+        
+        sprite.y = pysc.cap(sprite.y, 0+paddle_height/2, SCREEN_HEIGHT-paddle_height/2)
+
+        yield 1/game.framerate
+        
+game_start_event = sprite.when_game_start()
+game_start_event.add_handler(movement)
+
+

examples/simple_pong/main.py

@@ -0,0 +1,21 @@
+import pyscratch as pysc
+import pygame
+from pyscratch import game
+
+import right_paddle, left_paddle, ball, score_display
+
+SCREEN_HEIGHT = 720
+SCREEN_WIDTH = 1280
+
+
+game['running']=False
+game['score_left'] = 0
+game['score_right'] = 0
+
+game.load_sound('pong', 'assets/sound_effects/Metal Clang-SoundBible.com-19572601.wav')
+
+font = pygame.font.SysFont(None, 48)
+pysc.create_shared_data_display_sprite('left_score', font, size=(300, 60))
+
+game.update_screen_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+game.start(60, use_frame_time=True)

examples/simple_pong/right_paddle.py

@@ -0,0 +1,37 @@
+import pyscratch as pysc
+from pyscratch import game
+
+SCREEN_HEIGHT = 720
+SCREEN_WIDTH = 1280
+
+paddle_colour = (200, 200, 200)
+paddle_width = 20
+paddle_height = 130
+paddle_margin = 30
+
+sprite = pysc.create_rect_sprite(paddle_colour, paddle_width, paddle_height,  position=(SCREEN_WIDTH-paddle_margin, SCREEN_HEIGHT//2))
+
+#sprite.set_draggable(True)
+
+game_start_event = sprite.when_game_start()
+def movement():
+    while True: 
+        speed = 0
+        
+        if pysc.is_key_pressed('up'):
+            speed -= 8
+        if pysc.is_key_pressed('down'):
+            speed += 8
+
+        sprite.y += speed
+        
+        sprite.y = pysc.cap(sprite.y, 0+paddle_height//2, SCREEN_HEIGHT-paddle_height//2)
+
+
+        # wait for 1 frame
+        yield 1/game.framerate
+
+game_start_event.add_handler(movement)
+
+
+game['right_paddle'] = sprite

examples/simple_pong/score_display.py

@@ -0,0 +1,54 @@
+from attr import s
+import pyscratch as pysc
+import pygame
+from pyscratch import game
+
+SCREEN_HEIGHT = 720
+SCREEN_WIDTH = 1280
+
+font = pygame.font.SysFont(None, 48)
+
+
+score_board = pysc.create_rect_sprite((200, 200, 200), 150, 70, position=(SCREEN_WIDTH//2,SCREEN_HEIGHT//2))
+game_start_event = score_board.when_game_start()
+game['left_score'] = 0
+game['right_score'] = 0
+
+def display_score():
+    score_board.show()
+    l = game['left_score'] 
+    r = game['right_score'] 
+    score_board.write_text(f'{l} - {r}', font, offset=(150//2, 70//2))
+
+game_start_event.add_handler(display_score)
+
+
+left_score_event = score_board.when_receive_message('left_score')
+def left_score(data):
+    game['left_score'] += 1 
+    display_score()
+
+left_score_event.add_handler(left_score)
+
+
+right_score_event = score_board.when_receive_message('right_score')
+def right_score(data):
+    game['right_score'] += 1 
+    display_score()
+
+right_score_event.add_handler(right_score)
+
+
+def resume_game():
+    game['running'] = True
+    score_board.hide()
+
+def on_space_release(updown):
+    if  updown == 'up':
+        resume_game()
+
+
+game.when_key_pressed("space").add_handler(on_space_release)
+score_board.when_this_sprite_clicked().add_handler(resume_game)
+
+

pyscratch/__init__.py

@@ -0,0 +1,48 @@
+"""
+The reference manual is intended to provide technical specifications for the functions in this library. 
+If you are new to this library, visit [getting-started](../getting-started/). 
+# Namespace
+Everything in this library are directly under the pyscratch namespace. 
+So for example, you can use `pyscratch.game` to refer to `pyscratch.game_module.game` or `pyscratch.Sprite` to refer to `pyscratch.sprite.Sprite` etc. 
+
+When you do `import pyscratch as pysc`, they become just `pysc.game`, `pysc.Sprite` and `pysc.random_number` etc. 
+
+
+# Main Objects
+You will be mainly interacting of these following types of objects: 
+## 1. pyscratch.game_module.game (pysc.game)
+This is an object instead a type of objects. This object represents the game itself. 
+You use it to start the game, to play sound, change backdrops and make global changes to the game. 
+You can also use it to create events, but it is more convenient to create the events from the sprite.
+
+## 2. pyscratch.sprite.Sprite 
+The Sprite objects are the objects that represents the sprites in the game.
+
+
+## 3. pyscratch.event.Event & pyscratch.event.Condition
+This is the object you will get when you run `my_event = sprite1.when_game_start()`
+The only way you will interact with this object is to add handler functions to it and to remove it. 
+
+
+## 4. Pygame objects that represents the assets
+pygame is another library that this library depends on. 
+You only need to interact with these objects when you are loading the assets (for the sprites, backdrops and text styles)
+
+### 4.1. pygame.Surface
+A pygame object that represents an image. 
+All the images in this library are represented as pygame.Surface objects. 
+You can use pyscratch.helper.load_image to load an image for you. 
+
+### 4.2. pygame.font.Font
+A pygame object that represent the font (or the style of the text). 
+Some functions require the font object to render the text.
+To create a font object: 
+```python
+font = pygame.font.SysFont(None, 48)  # None = default font, 48 = font size
+```
+"""
+
+from .event import *
+from .game_module import *
+from .helper import *
+from .sprite import *