+demos

demos/draw_karel.py

@@ -0,0 +1,218 @@
+from graphics import Canvas
+from karel_asset import *   # https://git.h0v1n8.nl/Stanford/karel_asset
+from time import sleep
+
+ Constants    
+CANVAS_WIDTH = 420
+CANVAS_HEIGHT = 270
+canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT)
+
+
+def main():
+    background = canvas.create_rectangle(
+        0,
+        0,
+        CANVAS_WIDTH,
+        CANVAS_HEIGHT,
+        "grey",
+        "black"
+    )
+
+    while True: # Infinite loop
+        # Draw Western quadrant
+        karel_east = draw_karel(canvas, 35, 35, colour="random", background="random")
+        karel_east_mirrored = draw_karel(canvas, 85, 35, orientation="east-flipped", colour="random", background="random")
+        karel_west = draw_karel(canvas, 135, 35, orientation="west", colour="random", background="random")
+        karel_west_mirrored = draw_karel(canvas, 185, 35, orientation="west-flipped", colour="random", background="random")
+        karel_north = draw_karel(canvas, 35, 85, orientation="north", colour="random", background="random")
+        karel_north_mirrored = draw_karel(canvas, 85, 85, orientation="north-flipped", colour="random", background="random")
+        karel_south = draw_karel(canvas, 135, 85, orientation="south", colour="random", background="random")
+        karel_south_mirored = draw_karel(canvas, 185, 85, orientation="south-flipped", colour="random", background="random")
+        karel_east2 = draw_karel(canvas, 35, 135, colour="random", background="random")
+        karel_east2_mirrored = draw_karel(canvas, 85, 135, orientation="east-flipped", colour="random", background="random")
+        karel_west2 = draw_karel(canvas, 135, 135, orientation="west", colour="random", background="random")
+        karel_west_mirrored2 = draw_karel(canvas, 185, 135, orientation="west-flipped", colour="random", background="random")
+        karel_north2 = draw_karel(canvas, 35, 185, orientation="north", colour="random", background="random")
+        karel_north_mirrored2 = draw_karel(canvas, 85, 185, orientation="north-flipped", colour="random", background="random")
+        karel_south2 = draw_karel(canvas, 135, 185, orientation="south", colour="random", background="random")
+        karel_south_mirored2 = draw_karel(canvas, 185, 185, orientation="south-flipped", colour="random", background="random")
+        karel_east3 = draw_karel(canvas, 35, 235, colour="random", background="random")
+        karel_east_mirrored3 = draw_karel(canvas, 85, 235, orientation="east-flipped", colour="random", background="random")
+        karel_west3 = draw_karel(canvas, 135, 235, orientation="west", colour="random", background="random")
+        karel_west_mirrored3 = draw_karel(canvas, 185, 235, orientation="west-flipped", colour="random", background="random")
+        
+        # Wait one second
+        sleep(1)
+        
+        # Draw Eastern quadrant
+        karel_east4 = draw_karel(canvas, 235, 35, colour="random", background="random")
+        karel_east_mirrored4 = draw_karel(canvas, 285, 35, orientation="east-flipped", colour="random", background="random")
+        karel_west4 = draw_karel(canvas, 335, 35, orientation="west", colour="random", background="random")
+        karel_west_mirrored4 = draw_karel(canvas, 385, 35, orientation="west-flipped", colour="random", background="random")
+        karel_north4 = draw_karel(canvas, 235, 85, orientation="north", colour="random", background="random")
+        karel_north_mirrored4 = draw_karel(canvas, 285, 85, orientation="north-flipped", colour="random", background="random")
+        karel_south4 = draw_karel(canvas, 335, 85, orientation="south", colour="random", background="random")
+        karel_south_mirored4 = draw_karel(canvas, 385, 85, orientation="south-flipped", colour="random", background="random")
+        karel_east5 = draw_karel(canvas, 235, 135, colour="random", background="random")
+        karel_east5_mirrored = draw_karel(canvas, 285, 135, orientation="east-flipped", colour="random", background="random")
+        karel_west5 = draw_karel(canvas, 335, 135, orientation="west", colour="random", background="random")
+        karel_west_mirrored5 = draw_karel(canvas, 385, 135, orientation="west-flipped", colour="random", background="random")
+        karel_north5 = draw_karel(canvas, 235, 185, orientation="north", colour="random", background="random")
+        karel_north_mirrored5 = draw_karel(canvas, 285, 185, orientation="north-flipped", colour="random", background="random")
+        karel_south5 = draw_karel(canvas, 335, 185, orientation="south", colour="random", background="random")
+        karel_south_mirored5 = draw_karel(canvas, 385, 185, orientation="south-flipped", colour="random", background="random")
+        karel_east6 = draw_karel(canvas, 235, 235, background="pink")
+        karel_east_mirrored6 = draw_karel(canvas, 285, 235, orientation="east-flipped", colour="random", background="random")
+        karel_west6 = draw_karel(canvas, 335, 235, orientation="west", colour="random", background="random")
+        karel_west_mirrored6 = draw_karel(canvas, 385, 235, orientation="west-flipped", colour="random", background="random")
+        
+        # Wait one second
+        sleep(1)
+        
+        big_karel_east = draw_karel(canvas, 110, 135, 200)
+        
+        # Wait one second
+        sleep(1)
+        
+        big_karel_west_flipped = draw_karel(canvas, 310, 135, 200, orientation="west-flipped", colour="white", transparent=True)
+        
+        # Wait one second
+        sleep(1)
+
+        # Slide Karels out of the canvas        
+        for i in range(int(CANVAS_WIDTH / 5)):
+            karel_east = orientation_move_asset(karel_east, "forward", 5)
+            karel_east_mirrored = orientation_move_asset(karel_east_mirrored, "forward", 5)
+            karel_west = orientation_move_asset(karel_west, "forward", 5)
+            karel_west_mirrored = orientation_move_asset(karel_west_mirrored, "forward", 5)
+            karel_north = orientation_move_asset(karel_north, "forward", 5)
+            karel_north_mirrored = orientation_move_asset(karel_north_mirrored, "forward", 5)
+            karel_south = orientation_move_asset(karel_south, "forward", 5)
+            karel_south_mirored = orientation_move_asset(karel_south_mirored, "forward", 5)
+            karel_east2 = orientation_move_asset(karel_east2, "forward", 5)
+            karel_east2_mirrored = orientation_move_asset(karel_east2_mirrored, "forward", 5)
+            karel_west2 = orientation_move_asset(karel_west2, "forward", 5)
+            karel_west_mirrored2 = orientation_move_asset(karel_west_mirrored2, "forward", 5)
+            karel_north2 = orientation_move_asset(karel_north2, "forward", 5)
+            karel_north_mirrored2 = orientation_move_asset(karel_north_mirrored2, "forward", 5)
+            karel_south2 = orientation_move_asset(karel_south2, "forward", 5)
+            karel_south_mirored2 = orientation_move_asset(karel_south_mirored2, "forward", 5)
+            karel_east3 = orientation_move_asset(karel_east3, "forward", 5)
+            karel_east_mirrored3 = orientation_move_asset(karel_east_mirrored3, "forward", 5)
+            karel_west3 = orientation_move_asset(karel_west3, "forward", 5)
+            karel_west_mirrored3 = orientation_move_asset(karel_west_mirrored3, "forward", 5)
+
+            karel_east4 = orientation_move_asset(karel_east4, "forward", 5)
+            karel_east_mirrored4 = orientation_move_asset(karel_east_mirrored4, "forward", 5)
+            karel_west4 = orientation_move_asset(karel_west4, "forward", 5)
+            karel_west_mirrored4 = orientation_move_asset(karel_west_mirrored4, "forward", 5)
+            karel_north4 = orientation_move_asset(karel_north4, "forward", 5)
+            karel_north_mirrored4 = orientation_move_asset(karel_north_mirrored4, "forward", 5)
+            karel_south4 = orientation_move_asset(karel_south4, "forward", 5)
+            karel_south_mirored4 = orientation_move_asset(karel_south_mirored4, "forward", 5)
+            karel_east5 = orientation_move_asset(karel_east5, "forward", 5)
+            karel_east5_mirrored = orientation_move_asset(karel_east5_mirrored, "forward", 5)
+            karel_west5 = orientation_move_asset(karel_west5, "forward", 5)
+            karel_west_mirrored5 = orientation_move_asset(karel_west_mirrored5, "forward", 5)
+            karel_north5 = orientation_move_asset(karel_north5, "forward", 5)
+            karel_north_mirrored5 = orientation_move_asset(karel_north_mirrored5, "forward", 5)
+            karel_south5 = orientation_move_asset(karel_south5, "forward", 5)
+            karel_south_mirored5 = orientation_move_asset(karel_south_mirored5, "forward", 5)
+            karel_east6 = orientation_move_asset(karel_east6, "forward", 5)
+            karel_east_mirrored6 = orientation_move_asset(karel_east_mirrored6, "forward", 5)
+            karel_west6 = orientation_move_asset(karel_west6, "forward", 5)
+            karel_west_mirrored6 = orientation_move_asset(karel_west_mirrored6, "forward", 5)
+
+            # Wait a hundreth of a second
+            sleep(0.01)
+
+        # Erase Karels
+        erase_asset(karel_east)
+        erase_asset(karel_east_mirrored)
+        erase_asset(karel_west)
+        erase_asset(karel_west_mirrored)
+        erase_asset(karel_north)
+        erase_asset(karel_north_mirrored)
+        erase_asset(karel_south)
+        erase_asset(karel_south_mirored)
+        erase_asset(karel_east2)
+        erase_asset(karel_east2_mirrored)
+        erase_asset(karel_west2)
+        erase_asset(karel_west_mirrored2)
+        erase_asset(karel_north2)
+        erase_asset(karel_north_mirrored2)
+        erase_asset(karel_south2)
+        erase_asset(karel_south_mirored2)
+        erase_asset(karel_east3)
+        erase_asset(karel_east_mirrored3)
+        erase_asset(karel_west3)
+        erase_asset(karel_west_mirrored3)
+
+        erase_asset(karel_east4)
+        erase_asset(karel_east_mirrored4)
+        erase_asset(karel_west4)
+        erase_asset(karel_west_mirrored4)
+        erase_asset(karel_north4)
+        erase_asset(karel_north_mirrored4)
+        erase_asset(karel_south4)
+        erase_asset(karel_south_mirored4)
+        erase_asset(karel_east5)
+        erase_asset(karel_east5_mirrored)
+        erase_asset(karel_west5)
+        erase_asset(karel_west_mirrored5)
+        erase_asset(karel_north5)
+        erase_asset(karel_north_mirrored5)
+        erase_asset(karel_south5)
+        erase_asset(karel_south_mirored5)
+        erase_asset(karel_east6)
+        erase_asset(karel_east_mirrored6)
+        erase_asset(karel_west6)
+        erase_asset(karel_west_mirrored6)
+
+        # Slide big Karels into each other, first half
+        for i in range(int((310 - 110) / 2)):
+            big_karel_east = relative_move_asset(big_karel_east, 1)
+            big_karel_west_flipped = relative_move_asset(big_karel_west_flipped, -1)
+            # Wait a hundreth of a second
+            sleep(0.01)
+            
+        # Wait one second
+        sleep(1)
+        
+        # Invert big Karels
+        big_karel_east = recolour_asset(big_karel_east, "white", "black")
+
+        # Wait one second
+        sleep(1)
+
+        big_karel_west_flipped = recolour_asset(big_karel_west_flipped, "black")
+    
+        # Wait one second
+        sleep(1)
+
+        # Slide big Karels out of each other, second half
+        for i in range(int((310 - 110) / 2)):
+            big_karel_east = relative_move_asset(big_karel_east, 1)
+            big_karel_west_flipped = relative_move_asset(big_karel_west_flipped, -1)
+            sleep(0.02)
+
+        # Wait one second
+        sleep(1)
+
+        # Rotate big Karels eight times
+        for i in range(8):
+            big_karel_east = rotate_asset(big_karel_east, "left")
+            big_karel_west_flipped = rotate_asset(big_karel_west_flipped, "right")
+            # Wait three tenth of a second
+            sleep(0.3)
+
+        # Wait one second
+        sleep(1)
+
+        # Erase big Karels
+        erase_asset(big_karel_east)
+        erase_asset(big_karel_west_flipped)
+
+
+if __name__ == '__main__':
+    main()

demos/flash_karel.py

@@ -0,0 +1,49 @@
+from graphics import Canvas
+from karel_asset import *
+import random
+from time import sleep
+import asyncio
+
+
+# Constants    
+CANVAS_WIDTH = 400
+CANVAS_HEIGHT = 400
+
+
+async def flash_karel(canvas, delay:int=0):
+    await asyncio.sleep(delay)
+    karel = generate_random_karel(canvas)
+    await asyncio.sleep(4)
+    erase_asset(karel)
+
+
+async def main():
+    canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT,)
+    
+    while True:
+        background = generate_random_background(canvas)
+        sleep(0.5)
+
+        # Multple simultanious jobs
+        await asyncio.gather(
+            flash_karel(canvas, 0),
+            flash_karel(canvas, 1),
+            flash_karel(canvas, 2),
+            flash_karel(canvas, 3),
+            flash_karel(canvas, 4),
+            flash_karel(canvas, 5),
+            flash_karel(canvas, 6),
+            flash_karel(canvas, 7),
+            flash_karel(canvas, 8),
+            flash_karel(canvas, 9),
+        )
+        
+        sleep(0.5)
+        canvas.delete(background)
+    
+    return canvas
+
+
+if __name__ == '__main__':
+    #asyncio.run(main())
+    #await main()

demos/karel_slider.py

@@ -0,0 +1,121 @@
+from graphics import Canvas
+from karel_asset import *   # https://git.h0v1n8.nl/Stanford/karel_asset
+from time import sleep
+import asyncio
+
+# Constants    
+CANVAS_WIDTH = 400
+CANVAS_HEIGHT = 400
+canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT)
+
+""" This causes too much flashing, as the Karels are not drawn in sync, and overlap differently on updates.
+async def slide_karel(canvas, delay):
+    await asyncio.sleep(delay)
+
+    karel = generate_outofbounds_random_karel(canvas, "left")
+        
+    asyncio.sleep(1)
+
+    # Slide Karels out of the canvas
+    if canvas.width < canvas.height:
+        size = random.randint(1, canvas.width)
+    else:
+        size = random.randint(1, canvas.height)
+
+    for i in range(int(CANVAS_WIDTH + size * 2.5)):
+        karel = relative_move_asset(karel, x=+1)
+        await asyncio.sleep(0.01)
+        
+    erase_asset(karel)
+"""
+
+#async def main():
+def main():
+    while True: # Loop forever
+        background = generate_random_background(canvas)
+        sleep(0.5)
+
+        """ See too much flashing comment above
+        # Multple simultanious jobs
+        await asyncio.gather(
+            slide_karel(canvas, 0),
+            slide_karel(canvas, 3),
+            slide_karel(canvas, 7),
+            slide_karel(canvas, 9),
+            slide_karel(canvas, 12)
+        )
+        sleep(0.5)
+        """
+
+        """ Not random enough, looks a lot better than async Karels.
+        # Create Karels
+        karel0 = generate_outofbounds_random_karel(canvas, "left")
+        karel1 = generate_outofbounds_random_karel(canvas, "left")
+        karel2 = generate_outofbounds_random_karel(canvas, "left")
+        karel3 = generate_outofbounds_random_karel(canvas, "left")
+        karel4 = generate_outofbounds_random_karel(canvas, "left")
+
+        # Slide Karels
+        for i in range(random.randint(1, canvas.width)):
+            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
+            sleep(0.01)
+        for i in range(random.randint(1, int(canvas.width / 2))):
+            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
+            karel1 = relative_move_asset(karel1, x=+2)
+            sleep(0.01)
+        for i in range(random.randint(1, int(canvas.width / 3))):
+            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
+            karel1 = relative_move_asset(karel1, x=+2)
+            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
+            sleep(0.01)
+        for i in range(random.randint(1, int(canvas.width / 3))):
+            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
+            karel1 = relative_move_asset(karel1, x=+2)
+            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
+            karel3 = relative_move_asset(karel3, x=+3)
+            sleep(0.01)
+        for i in range(canvas.width):
+            karel0 = relative_move_asset(karel0, x=+random.randint(1, 2))
+            karel1 = relative_move_asset(karel1, x=+2)
+            karel2 = relative_move_asset(karel2, x=+random.randint(1, 7))
+            karel3 = relative_move_asset(karel3, x=+3)
+            karel4 = relative_move_asset(karel4, x=+4)
+            sleep(0.01)
+        
+        # Erase Karels
+        erase_asset(karel0)
+        erase_asset(karel1)
+        erase_asset(karel2)
+        erase_asset(karel3)
+        erase_asset(karel4)
+        """
+
+        # Set up asset stack
+        amount = random.randint(3, 10)  # Pick random amount of assets
+        stack = {}  # Create stack dictionary
+        for _ in range(amount): # Create the amount of assets
+            asset = generate_outofbounds_random_asset(canvas, "left", karel_prevelance=6)   # Generate asset
+            delay = random.randint(0, int(canvas.width * 2))    # Set random delay of a maximum of two canvas widths
+            speed = random.choice((1, 2, 3))  # Set random speed
+            name = "karel_" + str(_)    # Set dictionary key
+            stack.update({name: [asset, delay, speed]}) # Append entry to dictionary
+        
+        # Slide assets 
+        for i in range(canvas.width * 3):   # Slide for three canvas widths
+            for key, value in stack.items():    # Loop over asset dictionary
+                if value[1] < i:    # If delay has passed
+                    asset = relative_move_asset(value[0], x=+value[2]) # Move the Karel
+                    stack.update({key: [asset, value[1], value[2]]})    # Update the dictionary
+            sleep(0.01) # Wait shortly so the sliding is not CPU speed based
+        
+        # Erase assets in asset stack
+        for value in stack.values():
+            erase_asset(value[0])
+
+        # Erase background for in the next loop a new one will be created
+        canvas.delete(background)
+
+
+if __name__ == '__main__':
+    #await (main())
+    main()

demos/karel_spinner.py

@@ -0,0 +1,54 @@
+from graphics import Canvas
+from karel_asset import *
+from time import sleep
+import random
+
+
+# Constants    
+CANVAS_WIDTH = 400
+CANVAS_HEIGHT = 400
+
+
+async def main():
+    canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT)
+    
+    while True:
+        background = generate_random_background(canvas)
+        sleep(0.5)
+
+        karel0 = generate_random_karel(canvas)
+        karel1 = generate_random_karel(canvas)
+        karel2 = generate_random_karel(canvas)
+        #karel3 = generate_random_karel(canvas)
+        #karel4 = generate_random_karel(canvas)
+
+        direction0 = random.choice(["right", "left"])
+        direction1 = random.choice(["right", "left"])
+        for i in range(32):
+            karel0 = rotate_asset(karel0, direction0)
+            karel1 = rotate_asset(karel1, direction0)
+            karel2 = rotate_asset(karel2, direction1)
+            #karel3 = rotate_asset(karel3, direction1)
+            #karel4 = rotate_asset(karel4, direction1)
+            sleep(0.2)
+        for i in range(64):
+            karel0 = rotate_asset(karel0, direction0)
+            karel1 = rotate_asset(karel1, direction0)
+            karel2 = rotate_asset(karel2, direction1)
+            #karel3 = rotate_asset(karel3, direction1)
+            #karel4 = rotate_asset(karel4, direction1)
+            sleep(0.01)
+
+        erase_asset(karel0)
+        erase_asset(karel1)
+        erase_asset(karel2)
+
+        sleep(0.2)
+
+        canvas.delete(background)
+    
+    return canvas
+
+
+if __name__ == '__main__':
+    await main()

demos/karel_zoomer.py

@@ -0,0 +1,41 @@
+from graphics import Canvas
+from karel_asset import *   # https://git.h0v1n8.nl/Stanford/karel_asset
+from time import sleep
+    
+CANVAS_WIDTH = 400
+CANVAS_HEIGHT = 400
+
+def main():
+    canvas = Canvas(CANVAS_WIDTH, CANVAS_HEIGHT)
+    
+    while True: # Loop forever
+        background = generate_random_background(canvas)
+        sleep(0.5)
+
+        # Set up asset stack
+        amount = random.randint(5, 10)  # Pick random amount of assets
+        stack = {}  # Create stack dictionary
+        for _ in range(amount): # Create the amount of assets
+            asset = generate_random_asset(canvas, karel_prevelance=6, centre_x=int(CANVAS_WIDTH / 2), centre_y=int(CANVAS_HEIGHT / 2), size=0)   # Generate asset
+            delay = random.randint(0, int(canvas.width * 1))    # Set random delay of a maximum of two canvas widths
+            speed = random.choice((1, 2, 3, 4, 5))  # Set random speed
+            name = "karel_" + str(_)    # Set dictionary key
+            stack.update({name: [asset, delay, speed]}) # Append entry to dictionary
+        
+        # Slide assets 
+        for i in range(int(canvas.width * 1.5)):   # Zoom for 1.5 canvas widths
+            for key, value in stack.items():    # Loop over asset dictionary
+                if value[1] < i:    # If delay has passed
+                    asset = relative_resize_asset(value[0], size_difference=value[2]) # Resize the assset
+                    stack.update({key: [asset, value[1], value[2]]})    # Update the dictionary
+            sleep(0.01) # Wait shortly so the sliding is not CPU speed based
+        
+        # Erase assets in asset stack
+        for value in stack.values():
+            erase_asset(value[0])
+
+        # Erase background for in the next loop a new one will be created
+        canvas.delete(background)
+
+if __name__ == '__main__':
+    main()