What's this for?
    The Drawing Board (in case you don't know the cliche) is where new ideas are brought to life and refined a little before they are made a reality. Take a peek at this list of possible ideas and poke them around a bit. Just reading this stuff may give you an idea that is totally unrelated to what's here, but that's the idea of this page...to make you have ideas.

Concepts:

You know the kind of movies where you think you know what's going on but it's all something else? Make the object of the game be something totally different than what it appears to be. For example, when you start playing the game, the player gets the impression that the object is to escape from the dungeon, and when you escape, you find that you actually are the king, so you have to get back INTO the castle to try to prove it. Takes a lot of planning for a game like that, but they are awesome.

Gravity. There are many different ways to simulate gravity (in a game), but doing it properly is what makes it look good. A plain downward gravitational pull is simple: add a certain amount to the downward velocity of the object. But think about making an object go into orbit around another. You'll need to use trigonometry to figure the velocity changes, but if you do it properly, it looks really good and works like realy planetary orbit. What about making objects orbit around eachother (two moving objects)? Could get interesting.

Artificial intelligence is the holy grail of programming, isn't it. If you are going to attempt it, first of all read the article about it in the Articles section. Then remember the most important parts: keep track of data, analyze the data, change behavior because of analysis. If it's your first real, serious attempt, start with something very very small. Then when it works, you can go on from there.

Objects

If you want to make an object move around independantly, let's say, a box, use the POINT function to check the top, bottom, left, right sides of the box, then the corners too. If anything gets within one or two pixels of the object, make it move in to "get away" from what's touching it, unless there is something on the opposite side as well.

For making a ball bounce and be affected by other objects, you need to make "sensors" on each area of the ball. Use the POINT function to check 1 pixel away from the edge of the ball. The simplest way would be to check top, bottom, left, and right, but the more places you check, the more real the ball can be. When the ball hits something by its top or bottom, it's vertical momentum is reversed. When it hits something with its left or right sides, the horizontal momentum is reversed. Simple geometry makes those ones eazy. If you have sensors on the 45 degree angles of the ball, you have to reverse both the horizontal and vertical momentums of the ball. Now, for making the ball gain momentum by being hit, you have to have sensors extending further away from the ball so that it can determine how fast an object is approaching, then when it actually hits, the momentum can be affected. You'll only have to do one or the other of these methods. For a simple ball, use the first. For a ball that NEEDS to get hit by something, use the second method.

A simple corosshair design. No matter how it is the player moves the crosshair around, a neat way of displaying it is like this. Draw a small square as the center. Then draw a horizonal line from one side of the viewscreen to the other so that it has the same y coordinate as the crosshair. Draw a vertical line from top to bottom using the same x coordinate as the crosshair. Then you have a look that fills the viewscreen a little more, and integrates the crosshair into the systems of whatever the crosshair is for (ship controls, turret, radar, etc.)

Color

Palette rotating is extremely handy, for the most part in SCREEN 13. You can create sprites (moving or static) using graphical GET and PUT, then within the game loop run a palette rotating routine that makes colors used in the sprite change. Use color values you won't be needing for anything else to draw in parts of the sprite that will be changing color. Then in your palette rotation routine, make that color gradually change from color to color, then repeat, depending on what you need. Then anywhere you use the sprite, simply running the palette rotation routine will make its special parts change color.

3D-ish

Make two different sized circles with a common center-point (one inside the other). They represent a cylinder. Imagine a point, line, or rectangle on the surface of the cylinder. Mouse is the primary controller. Left/Right motion causes east/west rotation around the cylinder, and Up/Down motion causes the object to move north/south along the length of the cylinder.

Think paintball field. Rectangular area, obstacles that block bullets, try to get from one side to the other without getting hit, or capture the flag. Make it a pseudo-3D game by drawing the playing field as a trapezoid, long line at the bottom of the screen, shorter line near the top, connect the ends. The movement of the player is fairly simple when figuring out the two-dimensial coordinates. You just have to remember that for whatever Y (up/down) value the player is currently at, the X (left/right) movement is proportional to it: the further you are from the close end the field, the smaller increments of left/right movement you get with each step you take. As another possibility, the view of the field could be from the side, instead of the front, but the same movement rules apply.

A long time ago I made a game that involved flying through space shooting down alien ships. The main effect was the "starfield simulation" screen saver programmed to work within the boundaries of the viewscreen of my ship. The enemy ship would then move around in the viewscreen, and if it went off the screen you could track it on the radar screen. You had to steer the ship to get it back into view to shoot it again. The center of the starfield simulation simply moved slightly away from the center of the screen to simulate change of direction. Maybe you can recreate it and improve on this simple pseudo-3D concept.

Fixed-screen/Multi-screen

High resolution, divide the screen into three horizontal strips. Create a long landscape by starting at the left side of the top strip, moving right, then down to the next strip, then the last. Kind of like making a "word wrap" for a long area you may need.

Rethink Pinball. Instead of making a rectangle slant downward, make the play area out of a 1/2 sphere with the middle being the highest point in the game. You'll need flippers and deflectors all around the area, but that's what would make it unique. You'll need to know a little bit of trigonometry to simulate the gravitational effect the sphere has on the ball, then add that to the momentum the flippers change, but it's doable. Or maybe make the middle the lowest point, and have the flippers there?

If you like inventing puzzles, you know that you really have to think creatively to make something that hasn't already been thought of. Some tips for bending your ideas:

1. Make it circular instead of rectangular, or make it straight instead of round.
2. Look at the puzzle from a different "physical" point of view, draw it that way on the screen instead of what you had first thought.
3. Use laws of physics. Gravity, friction, light & visibility.
4. Combine ideas. Where you thought of two seperate puzzle concepts, try integrating them together somehow.

Spaceship games are some of the easiest to make, since space is black, stars can be simple points, QBasic can handle the both very well. To make a moving background: Use an array of stars, each moving in the same direction across the screen, but spread out of course. When one reaches an edge, move it back to a random spot on the opposite side of the screen. To make it look more space-like, move the stars at different speeds. In your programming you may want a type for the star: TYPE starobject x AS INT, y AS INT, movefactor AS FLOAT, maybe even col AS INT for the color. Then use DIM SHARED star(30) AS starobject, so you can use a FOR...NEXT loop to operate lots of stars, 30 in this case. star(number).movefactor will vary between say 1 and 0.7 so that when the background needs to move, each star is moved by multiplying the movefactor with the amount the background is supposed to move. The effect is that some stars are moving slower than others.

Warp points and hyperspace jumps make things interesting. A really old game called SpaceWar (cheer if you know it) was a battle between two space ships. If you got into too much trouble, you could make a hyperspace jump, which basically sent you to another part of the screen instantly. It was a cool feature. Maybe you should consider adding warp points, since they are very simple to control. When the character gets to the in-point, suddenly its coordinates change to the corresponding out-point. Good for complicating combat scenarios or mazes/puzzles.