Synchronization

Instructions related to synchronization allow our characters to organize things happen in the order we want.

If you get 1 point...

The easiest way to synchronize the behavior of your characters is using a 'wait' block, which makes the character waits the number of seconds you write as a parameter block. An example of how this block can be used to synchronize two characters:

                    when green flag clicked
                    say [Hello, how are you?] for (2) secs
                    wait (2) secs
                    say [Well, do you want to play hide-and seek?] for (3) secs
                    wait (1) secs
                    say [Let's go] for (2) secs
                    when green flag clicked
                    wait (2) secs
                    say [I'm fine, thanks!] for (2) secs
                    wait (3) secs
                    say [Yes] for (1) secs

In this case it uses blocks 'wait' to synchronize these two characters to maintain a conversation, so that while one speaks, the other character waits, and vice versa. Note that the number of seconds that each character expected, are equal to the number of seconds that the other character speaks, so they never talk at the same time.

If you get 2 points...

Synchronization using blocks 'wait' is very simple when programs are small and have few characters, but when are larger, or when we have several characters, or when conditions to generate a reaction can not be measured previously, it is more efficient to use other modes of synchronization and messages. Here's an example: 

                    when green flag clicked
                    say [Hello, how are you?] for (2) secs
                    forever
                    if < touching [mouse pointer v]?>then
                    broadcast [catched! v]
                    end
                
                    when I receive [catched! v]
                    say [You have catched my friend] for (2) secs
                    say [Now, you have to catch me!] for (2) secs

How do these syncblocks work? When a situation occurs in a character we want to cause a reaction in another character, we can use messaging. In the example, when the mouse touches the cat, the message 'Caught!', which will be sent to all the characters of the project is sent. Thus, when the butterfly receives the message 'Caught!', the instructions on the block 'when receive 'caught!''. Therefore, when the user touches the cat whit the mouse, butterfly says, 'You caught my companion. Now you have to catch me!'.

If you get 3 points...

In addition to sending messages, you can synchronize characters to make things happen in the order we want, using other blocks, such as 'wait until' or 'when the background changes to ...'.

                    wait until <(lives) =[0]>
                    say [Game over] for (2) secs
                    stop [all v]
                
                    when backdrop switches to [Spring v]
                    show
                    say [Spring has come!] for (2) secs


In the first example, when program execution reaches that point will stop until the condition is met in this case, until life is equal to 0. When lives equal to 0, then continue execution of the remaining blocks, this case, 'said Game Over' and 'stop all', which ends the execution of the project.
In the second example, the moment when the scene changes to the backdrop with the name 'Spring', the character will execute the blocks placed after the instruction 'when the backdrop changes to Spring', ie to be displayed and will say 'spring has come!'.


If you get 4 points...

To achieve a score of 4 points, you need to demonstrate advanced handling of messages and synchronization. Create complex interactions where multiple characters and conditions interact. For instance, use messaging along with 'if' blocks and loops to manage complex sequences and reactions. Your project should show a sophisticated use of these tools to coordinate actions across different sprites and events effectively.

An example can be: 

                    when green flag clicked
                    repeat until <(score) =[10]>
                    if <touching [edge v]?> then
                    broadcast [score updated! v]
                    end
                    end
                
                    when I receive [score updated! v]
                    change [score v] by (1)
                    if <(score) =[10]> then
                    say [You reached 10 points!] for (2) secs
                    stop [all v]
                    end

In this example, messaging and conditions are used to create complex synchronization. The first block waits until the score reaches 10, broadcasting a message when the edge is touched. The second block handles the message, updates the score, and stops the project when the score reaches 10.