8.8 directional control

Summary:

maybe we should consider the sprite?

8.8 directional control

hartnell 30 Aug 2007 15:19

I've already done some experimenting in the Yar research project. I thought 8d control was pretty straightforward. But in Yar the player object has a sprite that can face 8 directions with two subimages per direction. So, it accomplish this, all this code was necessary :

// code is GML, but should be obvious to anyone
if(keyboard_check(vk_up) and keyboard_check(vk_right))
{
    sprite_index = sprBugShipUR;
    x = x + bugShipSpeed;
    y = y - bugShipSpeed;
}
else if(keyboard_check(vk_up) and keyboard_check(vk_left))
{
    sprite_index = sprBugShipUL;
    x = x - bugShipSpeed;
    y = y - bugShipSpeed;
}
else if(keyboard_check(vk_down) and keyboard_check(vk_right))
{
    sprite_index = sprBugShipDR;
    x = x + bugShipSpeed;
    y = y + bugShipSpeed;
}
else if(keyboard_check(vk_down) and keyboard_check(vk_left))
{
    sprite_index = sprBugShipDL;
    x = x - bugShipSpeed;
    y = y + bugShipSpeed;
}else if(keyboard_check(vk_left))
{
    sprite_index = sprBugShipL;
    x = x - bugShipSpeed;
}else if(keyboard_check(vk_right))
{
    sprite_index = sprBugShipR;
    x = x + bugShipSpeed;
}else if(keyboard_check(vk_up))
{
    sprite_index = sprBugShipU;
    y = y - bugShipSpeed;
}else if(keyboard_check(vk_down))
{
    sprite_index = sprBugShipD;
    y = y + bugShipSpeed;
}

The multi-button diagonals needed to be checked first. And maybe it just me, but it makes sense that diagonal is faster than non-diagonal movement. Sometimes it seems like it is, sometimes not.

—hartnell

Last edited on 30 Aug 2007 15:20 by hartnell Show more

Re: 8.8 directional control

Anonymous (211.28.241.x) 31 Aug 2007 06:16

Rather than putting each combination of keypresses into an if, you could just do the usual keypress checks that let the player move in two directions at a time (but not in opposite directions) and then maybe compare the current co-ords to the previous ones and then set the sprite images accordingly.

But I also just got an idea, how about a system where, rather than you telling the game what image to use for each direction, how about let it do it itself. As in, with each possible keypress, you could add something a frame variable which is, after the keypress checks, used as the array index for which frame to use. So, let's say pressing right adds 1 onto the variable. We would do this because 1 is the array index for the frame for the right. However, pressing down would add 5 onto the variable (we are also assuming that the frame variable is reset with each loop), because frame 5 is the frame for down animation. However, if both are pressed, frame will be 5 + 1 (6). So we make our frame for down-right animation frame 6. :) This is probably confusing, but I could get a demo going if you want.

Re: 8.8 directional control

Linkage2 31 Aug 2007 06:18

(me)

Re: 8.8 directional control

u9 31 Aug 2007 10:53

excellent idea. Of the top of my head, i think it will work.

Here's how i in Asteroids of Fire select where to draw the border-particles of the playing field. To speed up execution i only draw these particles in one the 8 directions, i.e. left, right, up or down, and the 4 diagonal combinations, hence the similarities with 8-directional controls.

' Divide borders into 8 regions
Dim posx, posy, angle, region, dir
posx = player.pos.x - FIELD_CENTER_X
posy = player.pos.y - FIELD_CENTER_Y

' Get the angle between the center of the paying field and the player object
angle = getdirection( posx, posy )
region = round(8*(angle/(2*pi))) Mod 8

Here, region get's a value between 0 and 7 representing the direction. This will work for any-direction and will basically "snap-shot" the animation frame (region) to the closest that fits with which ever direction the player object has by e.g. looking at the difference in coordinates between this frame and the last frame.

for clarity here's some semi-pseudo code

' Movement since last frame
deltaX = player.pos.x - player.previousPos.x
deltaY = player.pos.y - player.previousPos.y

' Get the angle
angle = getdirection( deltaX, deltaY )
frameindex = round(NUM_FRAMES*(angle/(2*pi))) Mod NUM_FRAMES

If your language (as one of the few) uses degrees rather then radians for angles, then angle/(2*pi) should be replaced with angle/360.

Aaaaaaaaaaaah, my new QUAD-CORE computer just arrived…. i'm off to assembling!!! hmm… 4 cores… what to do, what to do… i definitely need to find a language with threads and set this baby to do some work!

Re: 8.8 directional control

hartnell 31 Aug 2007 21:11

As much as I would like to respond to this, I can't. My brain is still asleep. I'll be back later. I have the feeling we are on the verge of advancement. :) —hartnell

Re: 8.8 directional control

hartnell 31 Aug 2007 21:12

Something did occur to me, which I will post in another thread. —hartnell

Re: 8.8 directional control

u9 01 Sep 2007 13:59

Here's a little something i cooked up using Linkage's idea above. It does have different index numbers for the different directions, but they are not aligned in a circle, which coincidently would be great as it could then also be used for the movement.

Have a look.

graphics.initialize 800, 600
font = graphics.createfont( "system", 10 )
key.initialize

Do While Not key.pressed( vk_escape ) Or key.pressed( vk_windowx )
    If key.pressed( vk_right ) Then
        x = 500
        dir = 3
    ElseIf key.pressed( vk_left ) Then
        x = 300
        dir = 6
    Else
        x = 400
        dir = 0
    End If

    y = 300
    If key.pressed( vk_up ) Then
        y = 200
        dir = dir + 1
    ElseIf key.pressed( vk_down ) Then
        y = 400
        dir = dir + 2
    End If

    graphics.clear
    graphics.settext "Direction: " & dir, x, y, font, &hFFFFFFFF
    graphics.display
Loop

Re: 8.8 directional control

u9 01 Sep 2007 15:00

Another a bit more complicated implementation. Here the numbers are ordered all the way around, starting with 1 at up-right and moving in a counter clock-wise circle.

i use fixed numbers for the x-axis, and a multiplier and an offset for the other axis.

Do While Not key.pressed( vk_escape ) Or key.pressed( vk_windowx )

    If key.pressed( vk_up ) Then
        mul = 1
        off = 0
    ElseIf key.pressed( vk_down ) Then
        mul = -1
        off = 8
    Else
        mul = -2
        off = 10
    End If

    If key.pressed( vk_right ) Then
        dir = 1 * mul + off
    ElseIf key.pressed( vk_left ) Then
        dir = 3 * mul + off
    ElseIf mul = -2 And off = 10 Then
        dir = 0
    Else
        dir = 2 * mul + off
    End If

    graphics.clear
    graphics.settext "Direction: " & dir, 300, 300, font, &hFFFFFFFF
    graphics.display
Loop

Re: 8.8 directional control

u9 01 Sep 2007 15:06

And the final solution using a little trigonometry. Set x and y values according to key-presses, calculate the angle to them, and quantize this angle to a range of 8 different values. Works like a charm.

graphics.initialize 800, 600
font = graphics.createfont( "system", 10 )
key.initialize

Do While Not key.pressed( vk_escape ) Or key.pressed( vk_windowx )

    If key.pressed( vk_right ) Then
        x = 1
    ElseIf key.pressed( vk_left ) Then
        x = -1
    Else
        x = 0
    End If

    If key.pressed( vk_up ) Then
        y = -1
    ElseIf key.pressed( vk_down ) Then
        y = 1
    Else
        y = 0
    End If

    ' If no key pressed then use -1 as No-direction
    If x <> 0 Or y <> 0 Then
        ' I negate the y-axis because it is pointing down on the screen
        dir = Math.GetDirection( x, -y )
        dir = dir / (2*pi) ' dividing by 2pi because it is the full circle
        dir = round( dir * 8 )
    Else
        dir = -1
    End If

    graphics.clear
    graphics.settext "Direction: " & dir, 300 + x*100, 300 + y*100, font, &hFFFFFFFF
    graphics.display
Loop

Movement example coming next.

For those of you who do not have Brutus2D registered and cannot be bothered to re-write this example, here's an implementation of GetDirection() which you can use instead of Math.GetDirection() in the example above.

Public Function GetDirection(ByVal xVelocity, ByVal yVelocity)
    Dim Direction
    If xVelocity < 0 Then
        Direction = Pi + Atn(yVelocity / xVelocity)
    ElseIf xVelocity > 0 Then
        Direction = Atn(yVelocity / xVelocity)
        If Direction < 0 Then
            Direction = Direction + 2*Pi
        End If
    ElseIf yVelocity <= 0 Then
        Direction = 3*Pi/2
    Else
        Direction = Pi/2
    End If
    GetDirection = Direction
End Function

Re: 8.8 directional control

u9 01 Sep 2007 16:12

And finally, a movement example. I use (again) trigonometry to decide how much the player moves along each axis. If you want the player to move faster when moving diagonal, then just move the player when checking for key presses in each direction as Linkage suggested.

Let me know what you think :) Too much math? I think it would be nice if this could be wrapped up nicely in some kind of object (for those languages that support such). Any thoughts about that?

Note: This is done in Brutus2D, so the player's position coordinates are floats.

Note2: This is a good way of getting through the different aspects of games.

graphics.initialize 800, 600
font = graphics.createfont( "system", 10 )
key.initialize

playerX = 400
playerY = 300
speed = 4

Do While Not key.pressed( vk_escape ) Or key.pressed( vk_windowx )

    If key.pressed( vk_right ) Then
        x = 1
        ' Optionally move the player along the x axis here or use
        ' the movement example i use below with a little trigonometry
    ElseIf key.pressed( vk_left ) Then
        x = -1
    Else
        x = 0
    End If

    If key.pressed( vk_up ) Then
        y = -1
    ElseIf key.pressed( vk_down ) Then
        y = 1
    Else
        y = 0
    End If

    ' If no key pressed then use -1 as No-direction
    If x <> 0 Or y <> 0 Then
        ' I negate the y-axis because it is pointing down on the screen
        angle = math.GetDirection( x, -y )
        dir = angle / (2*pi) ' dividing by 2pi because it is the full circle
        dir = round( dir * 8 )
    Else
        dir = -1
    End If

    ' With the direction calculated, we can move the player in that direction
    If dir > -1 Then
        playerX = playerX + cos(angle) * speed
        playerY = playerY - sin(angle) * speed ' Again negated y-axis
    End If

    graphics.clear
    graphics.settext "Direction: " & dir, 10, 10, font, &hFFFFFFFF
    graphics.settext "O", playerX, playerY, font, &hFFFFFFFF
    graphics.display
    graphics.setfps 60
Loop

Re: 8.8 directional control

hartnell 01 Sep 2007 21:38

:) I can't wait to get everything done so I can dig into this. —hartnell

Re: 8.8 directional control

hartnell 02 Sep 2007 00:10

Ah, I had to reformat and no longer have the Math object. —hartnell

Re: 8.8 directional control

u9 02 Sep 2007 00:21

Don't worry, the GetDirection() function is in the post above. Just use that one instead of Math.GetDirection().