Pseudo games

There has been a trend over the time that degrades role playing games into what I call pseudo role playing games. Additionally there are games coming out made to look like role playing games, but not actually being role playing games, intentionally or unintentionally. This is a bit related to my last blog post about the unlocking system, since a pseudo RPG is basically a role playing game that has been degraded into more of an unlocking system.

A true role play game and an unlocking system have very similar mechanics, so it is hard to distinguish what is actually the problem here so let me start with a bit of explaining what an RPG Role Playing Game is:. A role playing game is a game where you play a role, well this is a kind of obvious, but the crucial part for it to be a true role playing game is, that you as a player have at least some degree of freedom of choice of what character or role you want to play, which then leads to different ways to play the game.

If you have a "role playing game" without that freedom of choice it basically becomes an adventure game or interactive movie, where your role is already set and you are basically just unlocking the stages that the game already set for you how your character will progress and this is what I coined "Pseudo RPG". It happened to me quite a few times where I bought or planned to buy a game, because I wanted to play an RPG just to find out later, it is only a pseudo RPG. It probably can be best seen in old RPGs that have later successors which turn more and more into pseudo RPG over time.

So the traditional pseudo RPG development is like, at first you have a lot of freedom of choice, like you want to play a warrior, mage or thief, which are the classic and most basic classes, old RPGs often have a lot more classes, but I want to just use that as an example now:. The most worrisome thing about it is its weaknesses. Salamence has four of them; Rock, Ice, Dragon and Fairy — with the Ice weakness dealing quadruple damage.

It has its fair share of things going for it, but just as many negatives as well. Hydreigon has five different type weaknesses, including a quadruple weakness to Fairy-types. That kind of makes it useless in that one specific match-up. Another dual Dragon-type, this time Ground, Garchomp has phenomenal stats and the same old debilitating Dragon-type weaknesses to Ice, Fairy and Dragon.

Its Mega Evolution may not be something you want to use, believe it or not. Adriano Valente is a writer from Montreal, Quebec. The World hands the Human any piece and then draws a new piece at random from the box. The Human places the newly acquired piece in the Future. If there was already a piece in the Future it moves to the Present. If there was already a piece in the Present it is returned the box.

If, at any time, the Human is too old, or too sick, to hold the card and move the pieces, they must teach the game to someone new. The new Human looks at the old Plan, now worn and faded, its corners soft and bent, quietly replaces it in the deck and chooses a new card at random. We will be accepting submissions until July 31st, pm EST. Then, throughout the month of August, we will be posting the poems on our site, leading up to the announcement of the winner on August 27th.

Posts will include your name, your Twitter handle optional , and your poem. We will use your email address only for the purposes of contacting you as the winner. Apologies for the confusion. I mean beyond the rules that appears above, is it possible to write freely or do we have to respect the structure of the example poem.

You can write freely but you will need to include, in some form, an overview of the game, the goal, the setup or starting conditions, and a brief summary of a play-through. If, however, you are using a segmented system, you can just use a list of commands. The distance that each command takes is equivalent to how quickly the invisible segment line drifts down the screen. This also frees you up to create a track format which works on a tile map, for representing somewhat realistic track geography.

That is, each tile could be one segment. A sharp turn could turn the track 90 degrees, while a more mild turn would come out at 45 degrees. Texturing the Road Now, you probably would like a real graphical texture on your road instead of the alternating lines and such that you have at the moment. A cheap and easy way to do it is this: You have a couple of textures for the road for the alternating line effect. When each horizontal line of the road is drawn, you stretch the texture to fit the width of that line.

Or, if you can't stretch, pick a line out of one of two complete road bitmaps ala Outrunners. If you want the road to look more accurate, make the Z for each line correspond to a row number on a texture graphic.

One textured road! However, if you only want strips of alternating color, the answer is even simpler-- especially when using fixed point. For each Z, make one of the bits represent the shade of the road dark or light.

Then, just draw the appropriate road pattern or colors for that bit. Varieties of Hills It seems there are a near-infinite number of ways to produce hill effects.

Hill effects have a wide range of geometric accuracy, with some of the less accurate techniques being more convincing than others. Here we will examine two possible methods. Faked Hills After much experimentation, I've come up with a flexible method for faking hills which uses little in the way of calculations.

Additionally, it accurately tracks objects which are beneath the horizon. It is a scaling and warping effect which vertically stretches and compresses the road. It uses the same addition trick used to draw the curves to generate the curvature of the hill. Here's how it's done: First of all, the drawing loop would start at the beginning of the Z Map nearest and stop when it gets to the end farthest. If we are to decrement the drawing position each line by 1, the road will be drawn flat. However, if we decrement the drawing position each line by 2, doubling lines as we go, the road will be drawn twice as high.

Finally, by varying the amount we decrement the drawing position each line, we can draw a hill which starts flat and curves upwards. If the next drawing position is more than one line from the current drawing position, the current Z Map line is repeated until we get there, producing a scaling effect.

Downhills are similar: If the drawing position is incremented instead of decremented, it will move beneath the last line drawn. Of course, lines which are below the horizon will not be visible on-screen-- only lines which are 1 or more pixels above the last line should be drawn.

However, we'll still want to keep track of objects which are beneath the horizon. To do this, note the screen Y position of each sprite as the Z Map is traversed. It may help to make the Z Map larger than needed for a flat road. This way, as the buffer stretches, it won't become too pixellated.

Now, we have to move the horizon to convince the player. I like to use a Lotus-style background in which the horizon doesn't just consist of just a skyline, but also a distant ground graphic.

When the hill curves upwards elongating the view , the horizon should move downwards slightly relative to the top of the road. When the hill curves downwards as the camera crests the hill shortening the view , the horizon should move upwards.

This is what the effect looks like for a downhill and an uphill-- minus the horizon graphic of course:. However, you may want to exaggerate the effect in order to get a more dramatic road. One thing that can be done with any of these curve formulas is to use high ddx or ddy values, but not allow dx or dy to exceed a sane value. And a user on YouTube, Foppygames, has discovered another trick for getting more severe curves out of these accumulation formulas: multiply the dx or dy value by the z value for each line!

This makes the curve more severe in the distance than it is in the foreground, and it creates a pretty convincing effect. And, the experimentation doesn't stop there. In fact, the best thing about these engines is that there's no "right" way of doing it.

Anything that creates curves and warpage which is pleasing to the eye is allowed! In my earliest road engines, I used a sinewave lookup table to bend the road. You can also use multiplication: To shift the road right, you might multiply the x position by, for example, 1.

To move it left the same amount, you'd multiply it by 0. However, armed with the knowledge that many old processors did not have multiplication or were slow at it, I settled upon using the accumulation technique because it only uses addition. It seemed the most likley "authentic" way of curving the road.

So, play around and experiment, and see what technique you like best! True 3d-Projected Segments 3d-Projected Segments vs. Raster Roads As nice as raster roads are, they can be made even more impressive by involving a simple form of polygon rendering. This form of rendering can actually be pulled off using the same limited raster hardware. However, it involves more calculations. Here's what it is: The track is made of polygonal segments. However, rather than moving in full 3d space, it still only moves towards the camera.

For curves, the road still just skews left and right in almost an identical way to the raster road: There is no actual rotation when going around curves as there would be in a full polygonal engine. Here's a rundown: Since we are still faking curves and road angles, that means expensive rotation calculations still won't be needed The road is essentially a strip of quads: each section of the road is attached to the next section.

This means we can calculate whether part of the road is visible or not based solely on its screen Y position relative to its previous neighbor. The relationship of these quads to one another will never change. That is, the angle never actually changes, so the quads are always and automatically sorted by Z.

The Basic 3d Road First, break the road into polygonal quads. Each of these will be called a segment. Just like a segment in a purely raster road, each segment here still has a curve amount ddx , and either a hill amount ddy or a y-position that determines how high up it is.

Of course, these can also have other attributes as well such as terrain changes. Or, if division is too slow, you could find the height off the ground of a given segment by multiplying the segment's height by the scaling factor for that line. That could then be subtracted that from a reverse z-map this map would be: for every z position of a flat road, what is the y?

Then, you would linearly interpolate the road widths and texture if desired between these heights. Scrolling the Road Now, we also need to learn how to scroll these segments.

Move the entire mess of polygons which make up the road towards the camera. As the frontmost segment's polygon passes through the camera, move the entire road back to its starting point so that it loops. This is akin to how a scolling 2d tilefield can be made by scrolling up to one tile-worth, and when that is hit all the tiles are shifted over and new tilemap data is pulled in. In this, we scroll up to one segment-worth, and when that is hit, we move the road back and pull in new road data.

But there is one last very important detail: Let's say the road is a sharp curve. You might have noticed that as you go around this polygonal curve that it jitters as you cross the segment boundary and the road is subsequently reset.

One obvious thing that is happening to cause this is that as you traverse a skewed segment, the camera's center relative to the road changes. That is, by the time you get to the end of that segment, the road is no longer centered. It's as if you're driving on the road at an angle.

You might be tempted to fix it by moving the road to center it just as objects' x-positions are linearly interpolated. However, this is wrong and does not completely solve our problem: If the road were skewed in a straight line, this would be fine. The problem is that our road curves, so the polygons in the distance still are not lined up! Another way to think about it is this: We are approximating a curve using polygonal segments.

We want the shape of the curve to be more or less constant even as it scrolls. Jake over at codeincomplete. Instead of changing the x position as the road as you move across the segment, what about changing the initial dx value from 0 to something that keeps the road in line as you move through the segment? In mathematical terms, doing this makes the X of the road a function of its Z. In other terms, we're keeping the curve the same shape regardless of how the points which approximate it scroll.

The frontmost segment is "pulled into position" with the rest of the road, which then means that the subsequent segments' X position are placed correctly. You can see this clearly if you test it with a road made of few polygons. It solves the following problems as the segment is traversed assuming the curve's shape does not change : It keeps the center of the road x position constant It adjusts dx so that the next segment starts at an appropriate x-location regardless of the scroll position of the road This video demonstrates the technique.

I've used very few segments and a very sharp curve to demonstrate how this looks. Notice that as the polygons move towards the player that they carve out a perfect curve shape. This is most apparent if you watch the right side of the road. Placing Sprites The sprites on that 3d segment would still need to be shown and properly cropped, however-- assuming you're making a custom renderer and not using a Z-buffer. We can actually draw the sprites as the last step: If a sprite is on a segment which is completely visible, it does not need to be cropped since it sticks straight up from the ground, which is our only polygon.

But if a sprite is on a segment which is either not visible or partially visible, we can easily crop it. First, find the top of the sprite. Then, every line of the sprite will be drawn until it hits the last visible segment's screen Y position. That is, if there is a segment behind the sprite which is supposed to cover part of it, you stop drawing the sprite when you hit that line.

And if the top of the sprite is below the last segment's Y position, the sprite won't be visible at all and will be skipped. Variations and Rendering Technologies Now, since we're throwing around the term polygon , you may be tempted to think that you need polygonal rendering routines to pull this off. Using technologies like OpenGL or a simple trapezoidal drawing routine definitely do work.

But even tile and sprite-based 2d hardware are perfectly capable of pulling this off. Observe that each road segment's beginning and end are perfectly horizontal. This means that they always start and end on a specific scanline. Much the way the purely pseudo-3d road is rendered on tile hardware by scrolling the flat road graphic as it's being drawn, we can do exactly the same with these 3d segments.

For further reading, check out the section called Dedicated Road Hardware. Though it discusses arcade hardware designed from scratch to draw road effects, the same technique can be achieved with basic 2d sprite-tile systems through scrolling the road graphic vertically as well as horizontally.

Further Reading on 3d-Projected Segments Since my mock-up of this specific variation is underdeveloped, I will point you to Code inComplete's amazing tutorial if you're interested in further details on this technique.

Multiple Roads Most arcade racing games handle multiple roads at a time. Though the most obvious reason to do this is to have more than one road on the screen at a time, other effects can be achieved as well.

For example, OutRun uses more than one road to form its six lane freeway. This lets the game widen and narrow the road easily, as well as convincingly fork. They do this by overlapping the two roads and giving one drawing priority over the other. Here is the familiar beginning of OutRun both with and without two roads look to the right of the bushes :. And, even more dramatic, below is the freeway after the two roads are overlapped to form six lanes, both with and without the second road:.

Endless Checkerboard The endless checkerboard in the arcade game Space Harrier is just a variation on the road technique. Like a road, the game contains graphics of lines coming at the player in perspective. In fact, Space Harrier uses the same hardware as Hang-On. Pictured below is the Space Harrier checkerboard effect with and without the palette changes. To turn this into a checkerboard, all that has to be done is to flip the color palette every few lines. Think of it as analogous to the light and dark strips on a road.

So, how then does it scroll left and right? This is just a variation on perspective-style steering: As the player moves to the left or right, the ground graphic is skewed. After a few pixels have scrolled past, the ground "resets" or "wraps" its position. This is how it appears to scroll endlessly to the left and right. Dedicated Road Hardware Although there are many ways to render roads, it is interesting to note that many arcade games used hardware designed for this specific purpose.

These chips automate the basics of road drawing, but not the road calculations themselves.