FInalized the beginner course. Enjoy

Author: liamrahav

README.md

@@ -41,7 +41,7 @@ AVbin is a package that provides some audio and the video support for Cocos2D Py
 Head to https://avbin.github.io/AVbin/Download.html to download the correct installer for your operating system.
 
 ###SDL
-SDL is the framework that PyGame (another Python game library) relies on for audio support. Cocos uses it for it's audio as well.
+SDL is the framework that PyGame (another Python game library) relies on for audio support. Cocos uses it for its audio as well.
 
 Head over to https://www.libsdl.org/download-1.2.php to download the base SDL library and then to https://www.libsdl.org/projects/SDL_mixer/release-1.2.html to download the Mixer library from SDL (which was what we will be using for audio support in our games)
 
@@ -73,9 +73,11 @@ From here you should be ready to start reading through the samples and trying ou
 
 It's important to note that `basics` does not mean Python basics! You should at least have a basic grasp on writing object oriented code before trying to jump into Cocos2D Python!
 
+*_I highly recommend that you browse through the code and READMEs on GitHub, and only using the cloned repository to run the games_*
+
 -------------------------------------------------------------
 
-Cocos has also provided some pretty good basic documentation and video samples, but unforunately it stops there. You can check those out here http://python.cocos2d.org/doc/programming_guide/index.html
+Cocos has also provided some pretty good basic documentation and video samples, but unfortunately it stops there. You can check those out here http://python.cocos2d.org/doc/programming_guide/index.html
 
 
 I created this repository because I found the Cocos2D Python documentation to be extremely limited, especially in code samples, beyond the basic level. It is also relatively complex and hard to understand. I often found myself needing to look at the source code for explanations on how to use certain classes and features. 

basics/assets/sound/LatinIndustriesSlow.wav

@@ -3,7 +3,7 @@
 
 Here is the order which the tutorial follows:
 
-1.  Getting Started (getting_started.py)
+1.  Getting Started (start.py)
 2.  Adding Actors (actors.py)
 3.  Basic Actions (actions.py)
 4.  Keyboard Input (keyboard.py)
@@ -12,4 +12,5 @@ Here is the order which the tutorial follows:
 7.  Audio Playback (audio.py)
 8.  Multiple Scene Games (scenes.py)
 9.  Transitioning Between Scenes (transitions.py)
-10.  Review (review.py)
+10. Effects (effects.py)
+11.  Review (review.py)

basics/basics.md

@@ -0,0 +1,31 @@
+from cocos.director import director
+from cocos.layer import ColorLayer
+from cocos.scene import Scene
+from cocos.sprite import Sprite
+from pyglet.window.key import symbol_string
+from cocos.actions import *
+
+
+class EffectLayer(ColorLayer):
+    is_event_handler = True
+
+    def __init__(self):
+        super(EffectLayer, self).__init__(231, 76, 60, 1000)
+
+        sprite = Sprite("assets/img/grossini_dance_08.png")
+        sprite.position = 320, 240
+        self.add(sprite)
+
+    def on_key_press(self, key, modifiers):
+        if symbol_string(key) == "T":
+            self.do(Twirl(amplitude=5, duration=2))
+
+        elif symbol_string(key) == "W":
+            self.do(Reverse(Waves(duration=2)))
+
+        elif symbol_string(key) == "F":
+            self.do(FlipX3D(duration=1) + FlipY3D(duration=1) + Reverse(FlipY3D(duration=1)))
+
+
+director.init()
+director.run(Scene(EffectLayer()))

basics/effects.py

@@ -11,6 +11,7 @@
 # I make the layer, set it to an event handler, and initialize the super class to begin
 class MouseInput(Layer):
     is_event_handler = True
+
     def __init__(self):
         super(MouseInput, self).__init__()
 

basics/mouse.py

@@ -4,8 +4,9 @@
 # Let's start with all of the inputs we need
 import cocos
 from cocos import scene
-from cocos.layer import Layer
+from cocos.layer import Layer, ColorLayer
 from cocos.director import director
+from cocos.scenes import *
 from cocos.sprite import Sprite
 from cocos.actions import *
 from cocos.audio.pygame.mixer import Sound
@@ -15,7 +16,8 @@
 
 # Here is how we will structure our code
 # First, we will write an Audio class that is the child of SDL's Sound class
-# Lastly we will write an Input layer that controls both the sprite and the audio
+# Second we will write an Input layer that controls both the sprite and the audio
+# And to spice things up, we'll add two states to the first layer: a normal and a trippy mode
 
 # We start with the audio class, same as before
 class Audio(Sound):
@@ -28,35 +30,46 @@ def __init__(self, filename):
 class InputLayer(cocos.layer.ColorLayer):
     is_event_handler = True
 
-    def __init__(self):
+    def __init__(self, x=320, y=240, is_trippy=False):
         super(InputLayer, self).__init__(46, 204, 113, 1000)
 
+        # We set the trippy boolean based on the value passed in (by default it's not trippy)
+        self.is_trippy = is_trippy
+
         # Now we need a little guy to manipulate
         self.sprite = Sprite('assets/img/grossini_dance_08.png')
-        self.sprite.position = 320, 240
+        self.sprite.position = x, y
         self.sprite.opacity = 0
         self.add(self.sprite)
         self.sprite.do(FadeIn(2))
 
         # You should be bored seeing this same code over and over again
         # Here's something different though
-        # Now I create a couple audio objects and store them within self
-        self.jump_sound = Audio("assets/sound/bounce.wav")
-        self.bg_music = Audio("assets/sound/LatinIndustries.wav")
+        # Now I create an audio object and store it within self, based on whether or not it's trippy
+        if self.is_trippy:
+            # When it is trippy, I have a slowed down and distorted version of the song I made in Audacity
+            self.bg_music = Audio("assets/sound/LatinIndustriesSlow.wav")
+            # I also start running a couple effects that make it seem very trippy
+            # It's important to note that you can do math on Cocos2D effects and actions
+            self.do((Waves(duration=4) * 100) + Liquid(duration=15))
+            # In this case I added two actions together and multiplied the waves by 100 for run
+        else:
+            # If it's not trippy then I just make it the same boring old song we've been using before
+            self.bg_music = Audio("assets/sound/LatinIndustries.wav")
+
         # We lower the volume of the background music and have it play the whole time
         self.bg_music.set_volume(.2)
         self.bg_music.play(-1)
 
         # We don't need anything else here, let's just let our sprite be moved in the event handlers
 
     # So now we can overload some default event handlers
-    # We'll let the user move in any direction on the screen with the arrow keys, and jump around with the spacebar
+    # We'll let the user move in any direction on the screen with the arrow keys
     # We'll only be doing keyboard input for this program
     def on_key_press(self, key, modifiers):
         # If you don't know what these next couple lines do, go check the previous tutorials
         move_left = MoveBy((-50, 0), .5)
         move_up = MoveBy((0, 50), .5)
-        jump = Jump(50, 0, 1, .25)
 
         # Check if they want to go left, and then actually make the sprite go left
         if symbol_string(key) == "LEFT":
@@ -66,15 +79,32 @@ def on_key_press(self, key, modifiers):
         elif symbol_string(key) == "RIGHT":
             self.sprite.do(Reverse(move_left))
 
-        # And lastly we need that jump game to be strong
+        # Lastly we need to make it move up
         elif symbol_string(key) == "UP":
             self.sprite.do(move_up)
 
+        # Oh yeah don't forget about down
         elif symbol_string(key) == "DOWN":
             self.sprite.do(Reverse(move_up))
 
+        # That's it for movements!
+        # Now let's look at transitioning to a new scene
+        # Let's make the game all trippy when they hit space
         elif symbol_string(key) == "SPACE":
-            self.sprite.do(jump)
+            # I need to stop the music before we transition to the next scene so that two songs aren't playing at once
+            self.bg_music.stop()
+
+            # If you were paying attention, you would've noticed I take three parameters in the init function
+            # I get the X and Y coordinates of the sprite to figure out where to place it when the scenes transition
+            coordinates = self.sprite.position
+            # You should try printing the X and Y coordinates yourself to see the type of object that it returns
+            if self.is_trippy:
+                # This line only runs when the layer is already trippy, and by default the layer makes itself not trippy
+                # This line only needs to give the X and Y coordinates in that case
+                director.replace(scene.Scene(InputLayer(coordinates[0], coordinates[1])))
+            else:
+                # This huge line makes a new scene, with a transition, and inputs the coordinates and makes it trippy!
+                director.replace(scene.Scene(InputLayer(coordinates[0], coordinates[1], True)))
 
 
 # And finally we do our usual initialization and run the scene

basics/review.py

@@ -4,8 +4,6 @@
 from cocos.scenes import FadeTransition, SplitColsTransition
 from cocos.text import Label
 
-
-
 # Here is all the same code we had before, but this time we will be adding transitions between the scenes
 # I won't be explaining what I already explained last tutorial
 class Layer1(ColorLayer):