Merge pull request 'improved-design' (#1) from improved-design into main

Reviewed-on: #1

cubito.py

@@ -1,11 +1,13 @@
 import turtle
+import os.path
 
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
 # Cell size
 distance = 90
 
 def start():
     # Set background - ocean
-    turtle.bgpic("background.png")
+    turtle.bgpic(f"{CURRENT_PATH}/background.png")
 
     # Set turtle cusor
     turtle.pensize(10)
@@ -17,14 +19,20 @@ def start():
     # Goto to first cell
     turtle.penup()
     turtle.goto(-225,225)
-    turtle.pendown()
+    #turtle.pendown()
 
 
 def fordward():
     """
     Forward fonction
     """
+    print(f"x : {turtle.xcor()}, y : {turtle.ycor()}")
     turtle.forward(distance)
+    
+    if turtle.xcor() > 226 or turtle.xcor() < -226:
+        turtle.backward(distance)
+    if turtle.ycor() > 226 or turtle.ycor() < -226:
+        turtle.backward(distance)
 
 def left():
     """

gui-arcade.py

@@ -5,46 +5,46 @@ ressources : https://api.arcade.academy/en/latest/resources.html
 
 import arcade
 import cubito
+import os.path
 
-
-SCREEN_MULTILPLIER = 1
+SCREEN_MULTILPLIER = 2
+SCREEN_MULTILPLIER /= 4
 
 # Screen title and size
 SCREEN_TITLE = "Cubito"
-SCREEN_WIDTH = int(500*SCREEN_MULTILPLIER)
-SCREEN_HEIGHT = int(500*SCREEN_MULTILPLIER)
-
-# Margin between mat & screen side
-VERTICAL_MARGIN_PERCENT = 0.10
-HORIZONTAL_MARGIN_PERCENT = 0.10
+SCREEN_WIDTH = int(2000* SCREEN_MULTILPLIER)
+SCREEN_HEIGHT = int(2000* SCREEN_MULTILPLIER)
 
 #Token row
-TOKEN_ROW = 10
-
-#Token start
-X_TOKEN_START = int(50*SCREEN_MULTILPLIER)
-Y_TOKEN_START = int(450*SCREEN_MULTILPLIER)
-
-# Space between tokens
-X_SPACING_TOKEN = int(45*SCREEN_MULTILPLIER)
-Y_SPACING_TOKEN = int(45*SCREEN_MULTILPLIER)
+TOKEN_ROW = 8
 
 # Token size
-TOKEN_SCALE = 0.5*SCREEN_MULTILPLIER
-TOKEN_HEIGHT = 75 * TOKEN_SCALE
-TOKEN_WIDTH = 75 * TOKEN_SCALE
+TOKEN_HEIGHT = int(160 * SCREEN_MULTILPLIER)
+TOKEN_WIDTH = int(160 * SCREEN_MULTILPLIER)
+
+# Token scale
+HELD_TOKEN_SCALE_MULTILPLIER = 1.4
+
+# Space between tokens
+X_SPACING_TOKEN = int(45*SCREEN_MULTILPLIER + TOKEN_WIDTH)
+Y_SPACING_TOKEN = int(45*SCREEN_MULTILPLIER + TOKEN_HEIGHT)
+
+# Token start
+X_TOKEN_START = int(108*SCREEN_MULTILPLIER + TOKEN_WIDTH / 2)
+Y_TOKEN_START = int(1618*SCREEN_MULTILPLIER + TOKEN_HEIGHT / 2)
 
 # List of token types
-TOKEN_TYPES = ["up", "left", "right", "hamburger"]
+TOKEN_TYPES = ["up", "left", "right", "function"]
 
 #Mat start
-X_MAT_START = int(250*SCREEN_MULTILPLIER)
-Y_MAT_START = int(400*SCREEN_MULTILPLIER)
+X_MAT_START = int(1072 * SCREEN_MULTILPLIER)
+Y_MAT_START = int(1648 * SCREEN_MULTILPLIER)
+X_MAT_FUNCTION_START = X_MAT_START
+Y_MAT_FUNCTION_START =  int(510  * SCREEN_MULTILPLIER)
 
 # Mat size
-MAT_PERCENT_OVERSIZE = 1.25
-MAT_HEIGHT = int(TOKEN_HEIGHT * MAT_PERCENT_OVERSIZE)
-MAT_WIDTH = int(TOKEN_WIDTH * MAT_PERCENT_OVERSIZE)
+MAT_HEIGHT = int(200 * SCREEN_MULTILPLIER)
+MAT_WIDTH = int(200 * SCREEN_MULTILPLIER)
 
 # Number of column & row mat
 MAT_COLUMN = 4
@@ -52,21 +52,20 @@ MAT_ROW = 4
 MAT_FUNCTION_ROW = 2
 
 # Space between mats
-X_SPACING_MAT = MAT_WIDTH + MAT_WIDTH * HORIZONTAL_MARGIN_PERCENT
-Y_SPACING_MAT = MAT_HEIGHT + MAT_HEIGHT * VERTICAL_MARGIN_PERCENT
-
-# Top for mats
-TOP_Y = SCREEN_HEIGHT - MAT_HEIGHT - MAT_HEIGHT * VERTICAL_MARGIN_PERCENT
-
-# Bottom for tokens
-BOTTOM_Y = MAT_HEIGHT / 2 + MAT_HEIGHT * VERTICAL_MARGIN_PERCENT
-
-# Start from left side
-START_X = MAT_WIDTH / 2 + MAT_WIDTH * HORIZONTAL_MARGIN_PERCENT
+X_SPACING_MAT = int(MAT_WIDTH + 30 * SCREEN_MULTILPLIER)
+Y_SPACING_MAT = int(MAT_WIDTH + 30 * SCREEN_MULTILPLIER)
 
+# Image
+X_START_MAIN_MAT_IMAGE = 1415 * SCREEN_MULTILPLIER
+Y_START_MAIN_MAT_IMAGE = 1304 * SCREEN_MULTILPLIER
+X_START_FUNCTION_MAT_IMAGE = X_START_MAIN_MAT_IMAGE
+Y_START_FUNCTION_MAT_IMAGE = 393 * SCREEN_MULTILPLIER
 
+# Couleur
+BACKGROUND_COLOR = (133, 100, 100)
 
 
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
 
 class Start_mat(arcade.SpriteSolidColor):
     def __init__(self, height, width, color=arcade.color.AMBER):
@@ -80,18 +79,25 @@ class Mat_function(arcade.SpriteSolidColor):
     def __init__(self, height, width, color=arcade.color.AMBER):
         super().__init__(width, height, color)
 
-
 class Token_sprite(arcade.Sprite):
     """ Token sprite """
 
     def __init__(self, token_type, scale=1):
         # Attributes for token type
         self.token_type = token_type
+        scale *= SCREEN_MULTILPLIER
+
+        self.image_file_name = f"{CURRENT_PATH}/Img/token/{self.token_type}.png"
 
-        self.image_file_name = f":resources:onscreen_controls/shaded_dark/{self.token_type}.png"
         # Call the parent
         super().__init__(self.image_file_name, scale, hit_box_algorithm="None")
 
+class Image(arcade.Sprite):
+    def __init__(self, file_name, scale=1):
+        self.image_file_name = f"{CURRENT_PATH}/Img/{file_name}"
+        scale *= SCREEN_MULTILPLIER
+        # Call the parent
+        super().__init__(self.image_file_name, scale, hit_box_algorithm="None")
 
 
 
@@ -102,7 +108,7 @@ class Cubito(arcade.Window):
         # Init parent class
         super().__init__(int(SCREEN_WIDTH), int(SCREEN_HEIGHT), SCREEN_TITLE)
         # Set background color
-        arcade.set_background_color(arcade.color.AMAZON)
+        arcade.set_background_color(BACKGROUND_COLOR)
 
         # List of tokens
         self.token_list = None
@@ -122,6 +128,9 @@ class Cubito(arcade.Window):
         # List of mats function
         self.mat_function_list = None
 
+        # List of mats
+        self.image_list = None
+
     def setup(self):
         """Set up the game"""
 
@@ -136,19 +145,20 @@ class Cubito(arcade.Window):
         self.mat_list = arcade.SpriteList()
         self.start_mat_list = arcade.SpriteList()
         self.mat_function_list = arcade.SpriteList()
+        self.image_list = arcade.SpriteList()
 
         for y in range(TOKEN_ROW):
             x = X_TOKEN_START
             for token_type in TOKEN_TYPES:
                 #placer les tokens
-                token = Token_sprite(token_type, TOKEN_SCALE)
+                token = Token_sprite(token_type)
                 token.position = x, Y_TOKEN_START - Y_SPACING_TOKEN * y
                 x += X_SPACING_TOKEN
                 self.token_list.append(token)
                 token.token_type
 
                 #placer des cases sous les tokens
-                start_mat = Start_mat(MAT_HEIGHT, MAT_WIDTH, color=arcade.color.AMAZON)
+                start_mat = Start_mat(MAT_HEIGHT, MAT_WIDTH, color=arcade.color.BEIGE)
                 start_mat.position = x - X_SPACING_TOKEN, Y_TOKEN_START - Y_SPACING_TOKEN * y
                 self.start_mat_list.append(start_mat)
 
@@ -160,28 +170,33 @@ class Cubito(arcade.Window):
                 self.mat_list.append(mat)
 
         # Placer les cases fonctions
-        Y_MAT_FUNCTION_START = Y_MAT_START - Y_SPACING_MAT * MAT_ROW
-
         for y in range(MAT_FUNCTION_ROW):
             for x in range(MAT_COLUMN):
                 mat = Mat_function(MAT_HEIGHT, MAT_WIDTH, arcade.color.BABY_BLUE)
-                mat.position = X_MAT_START + X_SPACING_MAT * x, Y_MAT_FUNCTION_START - Y_SPACING_MAT * y
+                mat.position = X_MAT_FUNCTION_START + X_SPACING_MAT * x, Y_MAT_FUNCTION_START - Y_SPACING_MAT * y
                 self.mat_function_list.append(mat)
 
+        # Placer les images
+        image = Image(file_name="case/Principal.png", scale=1)
+        image.position = X_START_MAIN_MAT_IMAGE, Y_START_MAIN_MAT_IMAGE
+        self.image_list.append(image)
+
+        image = Image(file_name="case/Fonction.png", scale=1)
+        image.position = X_START_FUNCTION_MAT_IMAGE, Y_START_FUNCTION_MAT_IMAGE
+        self.image_list.append(image)
 
     def on_draw(self):
         """Render the screen"""
         # Clear the screen
         self.clear()
 
+        #Draw the images
+        self.image_list.draw()
+
         #Draw the mat
-        self.mat_list.draw()
-
-        #Draw the start mat
-        self.start_mat_list.draw()
-
-        #Draw the mat function
-        self.mat_function_list.draw()
+        # self.mat_list.draw()
+        # self.start_mat_list.draw()
+        # self.mat_function_list.draw()
 
         # Draw the token
         self.token_list.draw()
@@ -211,6 +226,10 @@ class Cubito(arcade.Window):
             self.held_token = primary_token
             # Save the position
             self.held_token_original_position = self.held_token.position
+
+            # Expand the size of token
+            self.held_token.scale *= HELD_TOKEN_SCALE_MULTILPLIER
+
             # Put on top in drawing order
             self.pull_to_top(self.held_token)
 
@@ -223,6 +242,10 @@ class Cubito(arcade.Window):
 
             # See if we are in contact with the closest mat
             if arcade.check_for_collision(self.held_token, mat):
+                # Reduce the size of token
+                self.held_token.scale /= HELD_TOKEN_SCALE_MULTILPLIER
+
+                # Center the token
                 self.held_token.position = mat.center_x, mat.center_y
 
                 # Success, don't reset position of tokens
@@ -244,6 +267,10 @@ class Cubito(arcade.Window):
             # Where-ever we were dropped, it wasn't valid. Reset the each token's position
             # to its original spot.
             self.held_token.position = self.held_token_original_position
+            
+            # Reduce the size of token
+            self.held_token.scale /= HELD_TOKEN_SCALE_MULTILPLIER
+
 
         # We are no longer holding tokens
         self.held_token = None
@@ -265,6 +292,9 @@ class Cubito(arcade.Window):
             cubito.reset()
             print("Restart !")
 
+        if symbol == arcade.key.Q:
+            arcade.exit()
+
         if symbol == arcade.key.S:
             self.cubito()
 
@@ -287,8 +317,11 @@ class Cubito(arcade.Window):
                     cubito.left()
                 if token_type == "right":
                     cubito.right()
-                if token_type == "hamburger":
-                    self.cubito(function=True)
+                if token_type == "function":
+                    if function:
+                        return
+                    else:
+                        self.cubito(function=True)