pyscratch-pysc 1.0.3__py3-none-any.whl

assets/bullet_hell/old_verisons/player.py

@@ -0,0 +1,76 @@
+import random
+import re, sys
+import numpy as np
+import pymunk
+from pyscratch import game
+from pyscratch.sprite import Sprite, create_rect, create_rect_sprite
+from pyscratch.helper import _get_frame_dict
+from pyscratch.game_module import Game
+from main import *
+from enemy import *
+
+def game_start(data):
+
+    player = create_rect_sprite((0, 0, 255), 50, 30, pos=(720//2, 1200))
+    game._add_sprite(player)
+    game.create_edges()
+    player.set_collision_type(PLAYER_TYPE)
+
+
+    healthbar_red = create_rect((255, 0, 0), 60, 50)
+
+    healthbar_empty = create_rect_sprite((255, 255, 255), 60, 5, pos=(0,0))
+
+
+
+    game.shared_data['player'] = player
+    game.shared_data['inaccuracy'] = 5
+
+    player.sprite_data['health'] = 10
+
+
+    game._add_sprite(healthbar_empty)
+    healthbar_empty.lock_to(player, (0,-30))
+    healthbar_empty.blit(healthbar_red, (0,0))
+
+
+    #game.create_timer_trigger(100, 20).on_reset(lambda x: create_bullet_move_sine((355, 1), 0))
+    game.when_timer_reset(100, 20).on_reset(lambda x: create_bullet_attracted((355, 300)))
+    #game.create_timer_trigger(100, 100).on_reset(lambda x: create_bullet_type1((100, 100), 90))
+
+    #game.create_timer_trigger(100, 10)
+    
+    #game.create_timer_trigger(1200).on_reset(lambda x: shoot_player_bullet((player.x, player.y), game.shared_data['inaccuracy']))
+    #game.create_timer_trigger(500, 30).on_reset(lambda x: create_enemy_type1((random.random()*WIDTH, 0)))
+
+
+    def run_forever(_):
+        if game.is_key_pressed(['w']):
+            player.move_xy((0, -5))
+
+        if game.is_key_pressed(['s']):
+            player.move_xy((0, 5))
+
+        if game.is_key_pressed(['a']):
+            player.move_xy((-5, 0))
+
+        if game.is_key_pressed(['d']):
+            player.move_xy((5, 0))
+
+        player.set_xy((cap(player.x, 50, WIDTH-50), cap(player.y, HEIGHT-500, HEIGHT)))
+
+        
+    def on_health_change(change):
+        player.sprite_data['health'] += change
+        new_health = max(0, player.sprite_data['health'])
+
+        healthbar_red = create_rect((255, 0, 0), 60*(new_health/10), 50)
+        healthbar_empty.blit(healthbar_red)
+
+
+
+    game.when_timer_reset(1000/120).on_reset(run_forever)
+    game.when_receive_message('player_health').add_handler(on_health_change)
+
+
+game.when_timer_reset(0.1, 1).on_reset(game_start)

assets/bullet_hell/player.py

@@ -0,0 +1,89 @@
+import pyscratch as pysc
+from setting import *
+
+
+def spawn_player(event_test=False):
+
+   ...pyscratch# main sgame   player = pysc.create_rect_sprite((0, 0, 255), 50, 30, pos=(720//2, 1200))
+    #pysc.game.add_sprite(player)
+    player.set_collision_type(PLAYER_TYPE)
+
+
+    # custom data
+    pysc.game.shared_data['player'] = player
+    pysc.game.shared_data['player_health'] = 10
+    pysc.game.shared_data['bullet_period_ms'] = 200
+
+    # behaviour
+    ## 1. move by key press in a limited area
+    ## 2. health changes on message
+    ## 3. shoot bullet every n seconds (by messages)
+
+    ## 1. movement    
+    movement_event = pysc.game.when_timer_reset(1000/120)
+    def movement(_):
+        if game.is_key_pressed('w'):
+            player.move_xy((0, -5))
+
+        if game.is_key_pressed('s'):
+            player.move_xy((0, 5))
+
+        if game.is_key_pressed('a'):
+            player.move_xy((-5, 0))
+
+        if game.is_key_pressed('d'):
+            player.move_xy((5, 0))
+
+        player.set_xy((cap(player.x, 50, SCREEN_WIDTH-50), cap(player.y, SCREEN_HEIGHT-900, SCREEN_HEIGHT)))
+    
+    movement_event.add_handler(movement)
+
+
+    ## 2. health changes on message
+    health_change_event = pysc.game.when_receive_message('player_health')
+
+    def health_change(change):
+        pysc.game.shared_data['player_health'] += change
+
+    health_change_event.add_handler(health_change)
+
+
+    ## 3. bullets 
+    bullet_timer = pysc.Timer()
+    condition = lambda: (bullet_timer.read() > pysc.game.shared_data['bullet_period_ms'])
+    shoot_bullet_event = pysc.game.when_condition_met(condition)
+
+    def shoot_bullet(n):
+        pysc.game.broadcast_message('player_shoot_bullet', player)
+        bullet_timer.full_reset()
+
+    shoot_bullet_event.add_handler(shoot_bullet)
+
+    
+
+    # health bar
+    healthbar_empty = pysc.create_rect_sprite((255, 255, 255), 60, 5, pos=(0,0))
+    #pysc.game.add_sprite(healthbar_empty)
+    healthbar_empty.lock_to(player, (0,-30))
+
+    ## move the health bar
+    healthbar_red = pysc.create_rect((255, 0, 0), 60, 50)
+    healthbar_empty.blit(healthbar_red, (0,0))
+
+    # reusing the health_change_event defined about
+    def on_health_change(change):
+        new_health = max(0, pysc.game.shared_data['player_health'])
+
+        healthbar_red = pysc.create_rect((255, 0, 0), 60*(new_health/10), 50)
+        healthbar_empty.blit(healthbar_red)
+    
+    health_change_event.add_handler(on_health_change)
+
+    if event_test: 
+        shoot_bullet_event.remove()
+
+
+
+
+spawn_player(event_test=False)
+

assets/bullet_hell/player_bullets.py

@@ -0,0 +1,34 @@
+import pyscratch as pysc
+from setting import *
+import random 
+
+def shoot_player_bullet(player):
+
+    bullet = pysc.Sprite(frames, "circle_bullets", player.body.position)
+
+    #pysc.game.add_sprite(bullet)
+    bullet.set_collision_type(PLAYER_BULLET_TYPE)
+    bullet.set_rotation(-90)
+
+    movement_timer = pysc.game.when_timer_reset(1000/240).add_handler(
+        lambda x: bullet.move_indir(2)
+    )
+
+    next_frame_timer = pysc.game.when_timer_reset(100).add_handler(
+        lambda x: bullet.next_frame()
+    )
+
+
+    def destroy_when_exit(x):
+        movement_timer.remove()
+        next_frame_timer.remove()
+        pysc.game._remove_sprite(bullet)
+
+
+    destroy_condition = pysc.game.when_condition_met(lambda: (bullet.y < 0), repeats=1)
+    destroy_condition.add_handler(destroy_when_exit)
+
+
+
+
+pysc.game.when_receive_message('player_shoot_bullet').add_handler(shoot_player_bullet)

assets/bullet_hell/setting.py

@@ -0,0 +1,33 @@
+import pyscratch as pysc
+import pygame
+
+SCREEN_HEIGHT = 1280
+SCREEN_WIDTH = 720
+
+
+ENEMY_TYPE = 3
+PLAYER_TYPE = 2
+PLAYER_BULLET_TYPE = 4
+EDGE_TYPE = 1
+
+def cap(v, min_v, max_v):
+    return max(min(max_v, v), min_v)
+
+sprite_sheet = pygame.image.load("assets/09493140a07b68502ef63ff423a6da3954d36fd8/Green Effect and Bullet 16x16.png").convert_alpha()
+
+font = pygame.font.SysFont(None, 24)  # None = default font, 48 = font size
+
+frames = pysc.helper._get_frame_dict(sprite_sheet, 36, 13, {
+    "spin": [i+4*36 for i in range(14, 17+1)], 
+    "star_explosion": [i+4*36 for i in range(19, 22+1)], 
+    "heal": [i+1*36 for i in range(24, 28+1)], 
+    "circle_explosion": [i+5*36 for i in range(14, 17+1)], 
+
+
+    "square_bullets": [i+9*36 for i in range(24, 28+1)]+[i+9*36 for i in range(27, 24, -1)], 
+    "circle_bullets": [i+8*36 for i in range(24, 28+1)]+[i+8*36 for i in range(27, 24, -1)], 
+
+    "shield": [i+5*36 for i in [17]], 
+
+    "bullet1": [i+3*36 for i in range(7, 7+1)]
+})

examples/animated_sprite/main.py

@@ -0,0 +1,7 @@
+import pyscratch as pysc
+import my_sprite
+
+
+pysc.create_edge_sprites(thickness=0)
+pysc.game.update_screen_mode((1280, 720))
+pysc.game.start()

examples/animated_sprite/my_sprite.py

@@ -0,0 +1,79 @@
+import pyscratch as pysc
+from pyscratch.game_module import is_key_pressed
+
+
+# my_sprite = pysc.create_animated_sprite("assets/run")
+
+# def animate():
+#     my_sprite.scale_by(5)
+#     while True:
+#         yield 0.2
+#         my_sprite.next_frame()
+
+# my_sprite.when_game_start().add_handler(animate)
+
+
+my_sprite = pysc.create_animated_sprite("assets/my_sprite")
+my_sprite.oob_limit=100
+
+# variables for this sprite only
+my_sprite['frame_interval'] = 0.4
+
+# Event: on game start: switch frame
+def animate():
+    my_sprite.set_draggable(True)
+    my_sprite.direction = 20
+    my_sprite.scale_by(5)
+    my_sprite.set_animation("idle") # reference the folder name of the animation
+    while True:
+        yield my_sprite['frame_interval']
+        my_sprite.next_frame()
+
+my_sprite.when_game_start().add_handler(animate)
+#pysc.game._left_edge.hide()
+
+# Event: on game start: movement
+def movement(): 
+    speed = 10
+    
+    #my_sprite.set_rotation_style_left_right()
+    while True:
+        yield 1/30
+        my_sprite.if_on_edge_bounce()
+
+        if pysc.is_key_pressed("d"):
+            my_sprite.set_animation("run")
+            #my_sprite.direction = 0
+            my_sprite.x += speed
+            my_sprite['frame_interval'] = 0.2
+
+        elif pysc.is_key_pressed("a"):
+            my_sprite.set_animation("run")
+            #my_sprite.direction = 180
+            my_sprite.x -= speed
+            my_sprite['frame_interval'] = 0.2
+
+        elif pysc.is_key_pressed("s"):
+            my_sprite.set_animation("run")
+            #my_sprite.direction = 180
+            my_sprite.y += speed
+            my_sprite['frame_interval'] = 0.2
+
+        elif pysc.is_key_pressed("w"):
+            my_sprite.set_animation("run")
+            #my_sprite.direction = 180
+            my_sprite.y -= speed
+            my_sprite['frame_interval'] = 0.2
+
+        elif pysc.is_key_pressed("space"):
+            my_sprite.set_animation("run")
+            #my_sprite.direction = 180
+            my_sprite.move_indir(speed, -180)
+            my_sprite['frame_interval'] = 0.2
+        else: 
+            my_sprite.set_animation("idle")
+            my_sprite['frame_interval'] = 0.4
+
+my_sprite.when_game_start().add_handler(movement)
+
+

examples/bullet_hell/enemy.py

@@ -0,0 +1,152 @@
+import pyscratch as pysc
+from pyscratch import game
+
+def Enemy(position, speed, frame_idx, direction, bullet_period=0.4, path="assets/used_by_examples/bullet_hell/enemy"):
+    enemy = pysc.create_animated_sprite(
+        path,
+        position=position
+        )
+    enemy.set_animation('normal')
+    enemy.direction = direction#-90
+    enemy.set_frame(frame_idx)
+    enemy.set_scale(6/speed)
+
+
+    def movement(_):
+        while True: 
+            yield 1/game.framerate
+
+            enemy.move_indir(speed, 90)
+
+    movement_event = enemy.when_timer_above(0).add_handler(movement)
+
+    
+    def explode_and_remove():
+        movement_event.remove()
+        enemy.set_animation('explosion')
+        enemy.direction=0
+        enemy.scale_by(1.3)
+        enemy.when_timer_reset(0.1, 11).add_handler(lambda _: enemy.next_frame())
+        enemy.when_timer_reset(0.1*11, 1).add_handler(lambda _: enemy.remove())
+
+    def touch_player_bullet(_):
+        player = game['player']
+
+        while True: 
+            yield 1/game.framerate
+            if enemy.is_touching(player):
+                explode_and_remove()
+                return
+
+            for b in game['player_bullets']:
+                if enemy.is_touching(b):
+                    b.remove()
+                    explode_and_remove()
+            
+                    return
+
+    enemy.when_timer_above(0).add_handler(touch_player_bullet)
+
+    # shoot bullets
+    StandardBullet = game['StandardBullet']
+    enemy.when_timer_reset(bullet_period).add_handler(lambda _:  StandardBullet((enemy.x, enemy.y), direction+90, 10))
+
+    return enemy
+
+
+def spawn_standard_enemy():
+
+    x = pysc.random_number(0, game.screen_width)
+    y = 0
+    frame_idx = int(pysc.random_number(0, 9.999))
+
+    direction = pysc.random_number(-10, 10)
+
+    Enemy((x,y), pysc.random_number(2, 6), frame_idx, direction)
+
+def spawn_line():
+    n = 6
+    margin = 20
+    itv = (game.screen_width-margin*2)//(n-1)
+    y=0
+    for i in range(n):
+
+        x = itv*i+margin
+
+        Enemy((x, y), 5, 0, 0, bullet_period=1)
+    
+
+def spawn_6_side_entry():
+
+    pos1 = (0, 200)
+    pos2 = (0, 400)
+    pos3 = (0, 600)
+
+    pos4 = (game.screen_width, 200)
+    pos5 = (game.screen_width, 400)
+    pos6 = (game.screen_width, 600)
+
+    speed = 5
+    fidx = 2
+
+    Enemy(pos1, speed, fidx, 45-90)
+    Enemy(pos2, speed, fidx, 45-90)
+    Enemy(pos3, speed, fidx, 45-90)
+
+
+    Enemy(pos4, speed, fidx, 45)
+    Enemy(pos5, speed, fidx, 45)
+    Enemy(pos6, speed, fidx, 45)
+
+
+    
+
+def spawn_kamikaze():
+    x = pysc.random_number(0, game.screen_width)
+    y = 0
+    frame_idx = int(pysc.random_number(0, 9.999))
+    direction = pysc.random_number(-10, 10)
+
+    e = Enemy((x,y), 5, frame_idx, direction, bullet_period=1000)
+
+    # move towards player
+    e.when_timer_reset(1/game.framerate, int(10*game.framerate)).add_handler(lambda _: e.point_towards_sprite(game['player'], -90))
+
+def spawn_laser_enemy(x, y):
+
+    e = Enemy((x,y), speed=1, frame_idx=0, direction=0, bullet_period=1000, path="assets/used_by_examples/bullet_hell/enemy")
+    e.set_animation('laser')
+    e.scale_by(0.7)
+
+    Laser = game['Laser']
+    #player = game['player']
+    e.when_timer_reset(3).add_handler(lambda _: Laser((e.x, e.y), (e.x, e.y+1000), 1))
+
+def spawn_laser_enemy_pair(x):
+    spawn_laser_enemy(x, 0)
+    spawn_laser_enemy(game.screen_width-x, 0)
+
+
+
+game.when_timer_reset(2).add_handler(lambda _:spawn_standard_enemy()) 
+
+game.when_timer_above(3).add_handler(lambda _: spawn_line())
+game.when_timer_above(4).add_handler(lambda _: spawn_6_side_entry())
+
+game.when_timer_reset(7).add_handler(lambda _: spawn_line())
+game.when_timer_reset(6).add_handler(lambda _: spawn_6_side_entry())
+
+game.when_timer_reset(3).add_handler(lambda _: spawn_kamikaze())
+
+game.when_timer_reset(5).add_handler(lambda _: game['ExplodingBullet']((720/2-pysc.random_number(-50, 50), 0), 90, 5))
+
+game.when_timer_reset(10).add_handler(lambda _: spawn_laser_enemy(pysc.random_number(0, game.screen_width), 0))
+
+
+#game.when_timer_reset(1).add_handler(lambda _: game['Laser']((0, 0), (game['player'].x, game['player'].y), 1))
+
+
+
+
+        
+

examples/bullet_hell/enemy_bullet.py

@@ -0,0 +1,88 @@
+import numpy as np
+import pyscratch as pysc
+from pyscratch import game
+
+
+def StandardBullet(position, direction, speed):
+
+    bullet = pysc.create_animated_sprite(
+        "assets/used_by_examples/bullet_hell/normal_bullet",
+        position=position)
+    
+    bullet.direction = direction
+    bullet.set_scale(1.5)
+
+    
+    bullet['movement_event'] = movement_event = bullet.when_timer_reset(1/game.framerate).add_handler(lambda _: bullet.move_indir(speed))
+    bullet.when_timer_reset(0.2).add_handler(lambda _: bullet.next_frame())
+    
+    def detect_collision(_):
+        player = game['player']
+
+        if bullet.is_touching(player):
+            movement_event.remove()
+            bullet.when_timer_reset(0.1, 1).add_handler(lambda _: bullet.remove())
+
+    bullet.when_timer_reset(1/game.framerate).add_handler(detect_collision)
+    return bullet
+        
+game['StandardBullet'] = StandardBullet
+
+
+
+def ExplodingBullet(position, direction, lifespan):
+    speed = 5
+    main_bullet = StandardBullet(position, direction, speed)
+
+    def explode():
+        main_bullet['movement_event'].remove()
+        main_bullet.remove()
+        for i in range(12):
+            StandardBullet((main_bullet.x, main_bullet.y), i*30, speed*1.5)
+
+    
+    main_bullet.when_timer_reset(lifespan, 1).add_handler(lambda _: explode())
+
+
+game['ExplodingBullet'] = ExplodingBullet
+
+
+def Laser(pos0, pos1, duration):
+
+    len_x = pos1[0]-pos0[0]
+    len_y = pos1[1]-pos0[1]
+
+    length = (len_x**2 + len_y**2)**(1/2)
+
+    
+    path = "assets/used_by_examples/bullet_hell/lasers/3.png"
+    img = pysc.load_image(path)
+    w = img.get_width()
+
+    scaled_img = pysc.scale_to_fill(img, (w, length))
+
+
+
+    laser_sp = pysc.Sprite(dict(always=[scaled_img]))
+
+    laser_sp.direction = -np.arctan(len_x/len_y)/np.pi*180
+    laser_sp.x = (pos1[0]+pos0[0])/2
+    laser_sp.y = (pos1[1]+pos0[1])/2
+    laser_sp.set_transparency(0)
+    def change_alpha(_):
+        for i in range(30):
+            laser_sp.set_transparency(i/30)
+            yield 0.01
+        for i in range(30):
+            laser_sp.set_transparency(1-i/30)
+            yield 0.01            
+        laser_sp.remove()
+    laser_sp.when_timer_above(0).add_handler(change_alpha)
+
+
+game['Laser'] = Laser
+
+
+    
+    
+

examples/bullet_hell/main.py

@@ -0,0 +1,17 @@
+import pyscratch as pysc
+from pyscratch import game
+
+import player,player_bullet, enemy, enemy_bullet
+
+width = 720
+height = 1280
+sur = pysc.create_rect((50,50,50), width, height)
+
+
+game.set_backdrops([sur])
+game.switch_backdrop(0)
+
+game.update_screen_mode((width, height))
+game.start(show_mouse_position=True, event_count=True)
+#=game.save_sprite_states()
+

examples/bullet_hell/player.py

@@ -0,0 +1,39 @@
+import pyscratch as pysc
+from pyscratch import game
+
+player = pysc.create_single_costume_sprite("assets/used_by_examples/bullet_hell/player.png")
+game['player'] = player
+def movement():
+    player.set_scale(3)
+    player.set_xy((360, 1080))
+    
+
+    speed = 8
+
+    while True:
+        yield 1/game.framerate
+
+        if pysc.is_key_pressed('w'):
+            player.y -= speed
+
+        if pysc.is_key_pressed('s'):
+            player.y += speed
+
+        if pysc.is_key_pressed('a'):
+            player.x -= speed     
+
+        if pysc.is_key_pressed('d'):
+            player.x += speed
+
+player.when_game_start().add_handler(movement)
+
+
+def shoot_bullet():
+    Bullet = game['Bullet']
+    bullet_speed = 10
+    while True: 
+        yield 0.8
+
+        Bullet(player.x, player.y-35, bullet_speed)
+
+player.when_game_start().add_handler(shoot_bullet)

examples/bullet_hell/player_bullet.py

@@ -0,0 +1,31 @@
+import pyscratch as pysc
+from pyscratch import game
+
+game['player_bullets'] = []
+def Bullet(x, y, speed):
+    bullet = pysc.create_single_costume_sprite(
+        "assets/used_by_examples/bullet_hell/orb_bullets/6.png",
+        position=(x,y)
+    )
+    bullet.x = x
+    bullet.y = y
+    bullet.set_scale(0.5)
+
+    def movement(_):
+        while True:
+            yield 1/game.framerate
+            bullet.y -= speed
+
+    bullet.when_timer_above(0).add_handler(movement)
+
+
+    game['player_bullets'].append(bullet)
+    #return bullet
+
+game['Bullet'] = Bullet
+
+
+def clear_removed_bullet(_):
+    game['player_bullets'] = [b for b in game['player_bullets'] if not b.removed]
+
+game.when_timer_reset(2).add_handler(clear_removed_bullet)

examples/doodle_jump/main.py

@@ -0,0 +1,9 @@
+import pyscratch as pysc
+from pyscratch import game
+import player, platforms
+
+width = 720
+height = 1280
+
+game.update_screen_mode((width, height))
+game.start(60, show_mouse_position=True, print_fps=False)