[Game]Pokitto Grand Prix

[Hanski]

Here is the first work-in-progress version of the demo with the graphics by @Pharap. Looks quite nice already It runs at about 60 FPS. Use the 4-way-controller for steering and acceleration, and press the B button for an uncontrolled spin

PZero.bin (46.4 KB)

[Pharap]

From the looks of it you’ve had to shrink the sky line for some reason?
What size did you have to rescale to?

I think I’ll have to redo the road edging and come up with a better pattern for ‘out of bounds’ part.
It looks a bit gaudy at the moment.
(I had actually intended the purple things to be an alternate option to the green circles.)

---

Unfortunately there’s definitely noticable tearing on the roads.
At higher speeds it looks like there’s diagonal lines running through the road.

[Hanski]

From the looks of it you’ve had to shrink the sky line for some reason?
What size did you have to rescale to?

It is now 22x16 pixels. I think the proportion of the height of it to the screen height is now about the same as in F-Zero.

I think I’ll have to redo the road edging and come up with a better pattern for ‘out of bounds’ part.
It looks a bit gaudy at the moment.
(I had actually intended the purple things to be an alternate option to the green circles.)

The circle shape is good for the road edges because it looks good also when the road make curves.
The surface part pattern could contain both small detail and big patterns. The former look good in slow speed and the latter gives a sense of speed when going fast.

Unfortunately there’s definitely noticable tearing on the roads.
At higher speeds it looks like there’s diagonal lines running through the road.

I have to limit the max speed to some reasonable value

[Pharap]

@Hanski

It is now 22x16 pixels. I think the proportion of the height of it to the screen height is now about the same as in F-Zero.

Is the resolution for this display mode definitely 220x176?

I think I messed the calculations up slightly before, but now going by my calculations the height needed to match the FZero proportions would be ~34 for 220x176 or ~18 for 110x88.

using System;

namespace Lerp
{
    class Program
    {
        static double mapRange(double input, double inputMin, double inputMax, double outputMin, double outputMax)
        {
            return outputMin + (input - inputMin) * ((outputMax - outputMin) / (inputMax - inputMin));
        }

        const int FZeroImageHeight = 448;
        const int FZeroRoadHeight = 354;
        const int FZeroSkylineHeight = 94;
        const int PokittoHiresHeight = 176;
        const int PokittoLoresHeight = 88;

        static void Main(string[] args)
        {
            if (FZeroRoadHeight + FZeroSkylineHeight != FZeroImageHeight)
                throw new Exception("Assertion failed");

            Console.WriteLine("Hires:");
            Console.Write("Skyline: ");
            Console.WriteLine(mapRange(FZeroSkylineHeight, 0, FZeroImageHeight, 0, PokittoHiresHeight));
            Console.Write("Road: ");
            Console.WriteLine(mapRange(FZeroRoadHeight, 0, FZeroImageHeight, 0, PokittoHiresHeight));
            Console.WriteLine();

            Console.WriteLine("Lores:");
            Console.Write("Skyline: ");
            Console.WriteLine(mapRange(FZeroSkylineHeight, 0, FZeroImageHeight, 0, PokittoLoresHeight));
            Console.Write("Road: ");
            Console.WriteLine(mapRange(FZeroRoadHeight, 0, FZeroImageHeight, 0, PokittoLoresHeight));
            Console.WriteLine();

            Console.ReadKey();
        }
    }
}

Either way I might be able to redo the skyline graphic for a smaller size.

Edit:
If you’re sticking to 22x16 for the skyline, here’s one I redid from scratch:

And here’s it tiled 10 times:

@Hanski

The circle shape is good for the road edges because it looks good also when the road make curves.

Before I try to make another road border, it would be good to see some of the aternatives that I posted the other week:

@Hanski

The surface part pattern could contain both small detail and big patterns. The former look good in slow speed and the latter gives a sense of speed when going fast.

Rather than the sort of abstract mess that FZero has, I could attempt to do something that looks like a circuit board, or perhaps just some grass or desert?
Trying to make something city-like would be difficult because the buildings would probably end up looking flat.

If you want both small and big details, the tiles might have to be bigger than 16x16.
If making them larger is a problem, another alternative would be to do a small pattern with tiles and then have some large objects that are drawn on top of the tiles and generated randomly.
E.g. a dessert could have some cacti, a grassy plain could have trees

---

I’m currently reshading the ships.
Is this style of shading better, and do you think the lighter or darker looks better?

[Hanski]

Is the resolution for this display mode definitely 220x176?

Mode 13 is 110x88x8bit

If you’re sticking to 22x16 for the skyline, here’s one I redid from scratch:

Thanks!

Rather than the sort of abstract mess that FZero has, I could attempt to do something that looks like a circuit board, or perhaps just some grass or desert?

Those all sound fine to me.

If you want both small and big details, the tiles might have to be bigger than 16x16.
If making them larger is a problem, another alternative would be to do a small pattern with tiles and then have some large objects that are drawn on top of the tiles and generated randomly.
E.g. a dessert could have some cacti, a grassy plain could have trees

I am actually using 8x8 pixel tiles in the engine. Road border circles are made of 2x2 tiles. My engine currently uses 3-level abstraction:

• Tiles: 8x8 pixels
• Blocks: Contains 8x8 tiles
• Block map: The game field. Contains any number of blocks vertically and horizontally

[Hanski]

I’m currently reshading the ships.
Is this style of shading better, and do you think the lighter or darker looks better?

There is not much difference but I actually like the original “Pokitto” best, because there is a bigger contrast and clear line between light and shade areas. That gives it more depth in my opinion.

[Pharap]

Mode 13 is 110x88x8bit

Ok, I must have got mixed up for some reason.
Possibly got mixed up with Mode 15.

My engine currently uses 3-level abstraction:

• Tiles: 8x8 pixels
• Blocks: Contains 8x8 tiles
• Block map: The game field. Contains any number of blocks vertically and horizontally

I’m not quite sure what the difference is between the three.

There is not much difference but I actually like the original “Pokitto” best, because there is a bigger contrast and clear line between light and shade areas. That gives it more depth in my opinion.

Ok, I’ll see what I can do.

I’m trying to make sure there’s a pattern to the colours being used so it’s easy to make them lighter/darker.

[spinal]

My engine currently uses 3-level abstraction:

• Tiles: 8x8 pixels
• Blocks: Contains 8x8 tiles
• Block map: The game field. Contains any number of blocks vertically and horizontally

I’m not quite sure what the difference is between the three.

The block map is an array of tile maps. So that you don’t need a huge array to store a huge level map.

[Pharap]

Oh right, that sort of thing. Normally I’d call that chunking (since that’s what Minecraft calls it).
(We used chunking when making Dark & Under.)

[Pharap]

@Hanski

There is not much difference but I actually like the original “Pokitto” best, because there is a bigger contrast and clear line between light and shade areas. That gives it more depth in my opinion.

For colouring I’ve got a system of ‘shades’ where 1 ‘shade’ is 0b0001000 (or 0x08) in RGB888 terms (which is the ‘epsilon’ of R and B in RGB565).
This allows me to lighten or darken images by adjusting the ‘shade’ of every colour used and to increase contrast by changing the step between ‘shades’.

The two ships I had before were 2 ‘shades’ apart for each colour.
This new one here is 4 ‘shades’ apart for each colour:

[Hanski]

Anybody knows any neat algorithms for NPC ships that the user is racing against? Like:

• Predefined path: there are predefined control points in the track and the NPC ship path is interpolated to follow those.
• the NPC ship detects the track left and right edges and randomly wanders between them. It can also try to block the player ship.

[jonne]

I have a book on Game AI. I’ll pop upstairs and see if it has anything on the subject.

[Pharap]

Is the road perpetually straight or will there twists and turns.
And will the road be randomly generated or will there be a map?
(Has an impact on what options are available.)

I found this:
https://www.gamasutra.com/view/feature/3920/the_pure_advantage_advanced_.php?print=1

You can skip most of it and head straight to the ‘Implementation’ section.
Upon reading it I feel kind of cheated because I suspect racing games that I’ve played are doing something similar, but it’s an interesting approach.

[jonne]

Nothing really on this subject in the book (Programming Game AI by Example / Mat Buckland)

Of the top of my memory car games use a combination of waypoints & “look-ahead” envelope and collision avoidance.

This means:

• optimal path through the course is mapped as waypoints. Waypoints include optimal velocity
• computer vehicles steer towards waypoints
• computer behaviour is limited to n waypoints ahead (ie. behave in a more “natural” way)
• in the close proximity, computer vehicles are governed by proximity / collision detection
• eventual path becomes a compromise between proximity behaviour and trend towards optimal set waypoints

[Hanski]

There will be turns and there is a map also.

Yeah, looks like we can win only if the computer kindly lets us, poor humans, to do so

[spinal]

@Hanski

Anybody knows any neat algorithms for NPC ships that the user is racing against? Like:

I think for MarioKart, the track are split into rectangle regions, each having a destination point within the next region. So an npc is always driving towards the ‘next’ region. Something like this…

[edit] Like Jonne said

[Pharap]

I’ve got to dash off for the day, but here’s a half-scribbled mess of ideas that I’ll attempt to explain tomorrow:

(Probably the scruffiest thing I’ve drawn in a while.)

Basically it should be possible to calculate:

• A way for a car to overtake the player
• A way for a car to avoid colliding with the player
• A way for a car to correct its path after having to dodge the player

Most of which use velocity vectors.
The ‘path correction’ requires a node map (a list of points would suffice, perhaps with weights or vectors for creating curves/interpolating).

I haven’t actually figured out and of the maths involved, these are just ideas off the top of my head, but I’m reasonably convinced that they’re possible.

---

And obviously the AI is going to need to be a sort of state machine, perhaps built with a sort of ‘strategy pattern’ to make it easier to change the behaviour.

[Hanski]

A lot of good ideas! A picture always makes it clearer to me.

I think that the first step would be just placing waypoints/control points/destination points throughout the course. Each waypoint contains the position (obviously), speed, and rotation vectors. Then I just interpolate each vector between the current state and the waypoint. The problem would be that the ships are going one after another throught the same route, but that can be helped by having some randomness on how fast they interpolate.

After that more AI can be added.

Also I was thinking to try to add some (simple) audio early in the development, to see how much it affects to the performance.

Btw. I have now done a very fast scaling and blitting implementation of an arbitrary bitmap, which can be used to scale npc ships and other objects in the horisont. Maybe also mipmapping is of better use there.

[jonne]

Also I was thinking to try to add some (simple) audio early in the development, to see how much it affects to the performance.

Let me add a few sound features to make it a bit easier. Been meaning to do it now that the tracker is mostly functional

[Hanski]

What are you planning to do?