Using Python in the Blender Game Engine - Part 4

Hey, there. It's been a little while since the last tutorial post, but here's Part 4 in the series of game development in the Blender Game Engine using Python to make the maze-type game Maze Crawl.

There's only a little bit of changes to the code this time around in the tutorial series. Let's see what the differences are.

from bge import logic
from bge import events

def Sign(value):
    if value > 0:
        return 1
    elif value < 0:
        return -1
    else:
        return 0
      
def AxisCheck(mx, my, size = 1.0):

    cont = logic.getCurrentController()
    obj = cont.owner

    pos = obj.position                                    # Get the Player's current position
    topos = pos.copy()                                    # Make a copy of the Player's current position
    topos.x += (Sign(mx) * size) + mx                    # Offset the copy by the movement value for the X-axis
    topos.y += (Sign(my) * size) + my                    # And offset the copy by the movement value for the Y-axis
  
    return obj.rayCast(topos, pos, 0, 'wall', 1, 1)        # We may have just collided with something on the line specified
  
def Player():
    cont = logic.getCurrentController()
    obj = cont.owner
  
    motion = cont.actuators['Motion']
  
    key = logic.keyboard.events
    kbleft = key[events.LEFTARROWKEY]
    kbright = key[events.RIGHTARROWKEY]
    kbup = key[events.UPARROWKEY]
    kbdown = key[events.DOWNARROWKEY]
  
    def Init():
        if not 'init' in obj:
            obj['init'] = 1
  
    def Update():
  
        movespd = 0.2
        mx = 0.0
        my = 0.0
      
        if kbleft > 0:
            mx = -movespd
        elif kbright > 0:
            mx = movespd
      
        if kbup > 0:
            my = movespd
        elif kbdown > 0:
            my = -movespd
          
        if AxisCheck(mx, 0, 1.0)[0] != None:    # We just collided with something on the X-axis
            mx = 0    # So stop movement on the X-axis

        if AxisCheck(0, my, 1.0)[0] != None:    # We just collided with something on the Y-axis
            my = 0  # So stop movement on the Y-axis
      
        motion.dLoc = [mx, my, 0.0]
        cont.activate(motion)
          
    Init()
    Update()
    
Okay, so maybe it's not just a few changes... Anyway, as you can see, there is a major difference in code between the previous part in the series and this one, but the actual amount of tasks finished by the code is the same. What we have done in the source code here is define a new function called AxisCheck that checks for a collision on the given X and Y axes and a distance value (wrongly called size in the example, LOL). This check is initiated by calling the new AxisCheck function with the X, Y, and distance arguments, as can be seen above.

You can also see that the new AxisCheck function uses another new function, the Sign function. The Sign function returns the sign of the inputted number - if the number is greater than 0, it returns 1. If the number is less than 0, it returns -1, and if the number is 0, then 0 is returned. This simply converts the motion amount into a uniform value that we use in collision checking.

That's the only difference in code for this part - there's another difference actually in the source .blend file. Before this part in the tutorial series, the Player cube was a Sensor-type collision object. Sensor-type objects are basically ghost-type Static objects, except that they can test for collisions against Static-type objects. However, Sensors can't detect collision against other Static sensors, and Static-type objects can't detect collisions for Sensors (the collision event is only generated one way). So, how do we navigate this?

Well, it's actually quite simple. We set the Player cube to be Dynamic. Since we control its movement with Python, we won't need the Bullet physics engine to compute collisions on the cube itself, so we make it Ghost-type. Also, we'll control gravity (or lack thereof in this maze-type game), so we also turn the global gravity to 0. Why do all of this?

As you can see, the Dynamic Ghost is highly versatile.

Because, as is seen in the diagram, with the Player set to a Dynamic Ghost-type object, we can check for collisions against scenery (static-type) or other game objects (other Dynamic Ghost-types). This freedom of collision-checking is something that will surely help us control our game dynamics.

Here is the source code for Part 4 of the Maze Crawl Source Code, made in the Blender Game Engine. Have fun!

Note: I'm trying out a new download host (MediaFire), so if the download goes down, E-Mail me at solarlune@gmail.com and I'll sort things out.