I was curious as to what techniques and approaches people use to design and code games in Lite-C.
When you start thinking about a coding a game you must think about breaking it into functions. How these functions are called and interact needs to be planned.

How do YOU plan and design your games ?

Thanks

i use boxes,flowcharts. I think , take notes, revise the flowchar till t's perfect.

(like a map, first a whole world overview flowchart, then for more detiailed flowcharts, so on.)

i am not sure if that d work well for large projects tho.

The game design is really, for me, an inspiration thing. Keep a notepad handy and jot ideas down as they appear.
Inspired by other games(note the game so you dont get too similar), movies and music all work well for me.
Go out of your way to watch movies of that theme, no matter how good they look, little details/scenes are what work.


I dont think my coding approach is NOT the best for everybody, but it works for me.

1: Break it up into MAJOR blocks that interact minimally. (ie menus, game, in-game-menus, configs)

2: Make each of the MAJOR blocks a separate include, with the main .C file containing no actual coding for now,
just the include statements, and maybe splashscreen/titles screens.

3: Start with the non-game blocks and get them 'functional', even if the bells and whistles are missing till later,
beause these blocks will change as the game develops/mutates over time, especially the in-game menus.

Now it starts to get blurry, it depends a lot on the game type. But usually start with a basic level
with crude entity models and build on that.

4: Initially get a crude level built and concentrate on getting ALL the player movements/physics right,
then build the final, fully-animated player model and tests his movements and make sure they still work OK.
Tweak as necessary.

5: Give life to your enemies with limited AI, give them their life etc. And animate.
Create the final model and all animations. For ALL the enemies there will be in the entire game.

6: Create all weapons and their special effects/damages and test them with player on movement limited enemies.

7: Create animate and animated-background models, special effects, sky-scenes etc.

8: Design and implement the actual levels with actual graphics/models/animated backgrounds, and test before putting in
any before player or enemies.

9: Design and implement level changing system.

10: Finalise and bugtest other MAJOR modules.(main menu etc)

And thats pretty much it.


As for functions and there names, once again this works for me, but maybe not for all.
A: Build a single function to do everything for a specific entity and include the entities type in the name.
EG player_action()

B: As the function grows, you may see code being repeated, split that off into s separate function.
EG player_do_gravity

B1: Sometimes the split-off code will be useful to other entities. Than name it generically.
EG entity_do_gravity

C: As you create new entitys code, you'll find bits in it repeat, or nearly repeat code in other entity-functions.
Split that off in both entities and tweak to be multi-entity generic code like B1.

D: If the function gets too big, split off large sections that live inside the same IF statement.
In the end we will want our action to be as small as possible to speeds sake.

E: Once its all done remember, each ACTION type function should be small, as it may be running in
multiple instances so smaller is better. Calling another function when needed is better than having
it clogging up memory when its not needed, especially multiple times.


That will do, my fingers are getting sore...

I just chug along with it one little piece at a time. Usually starting with menus.

Hi!

I do a sketch of what I want
Then
I have a practice areas sssssss.

one work_alpha ....for text, strings...

one work_struct ....for struct

And when it works I bring it back to the big one

They all use the same models, tga, pcx ....folders

Ottawa.

I do it likeinthe rpg-maker xp

Game_Variables.c
Game_Strins.c
Game_Hero.c
...and so on

That gives me muchorganisation power, and can give ready projects to others, and they understand everything.

I have only just started to think about this as up until now my programs have been small testing programs. Now I want to design a bigger project and it occured to me that just jumping in with code would be almost impossible.

For me, the hardest part is knowing what functions to create. I suppose there will always been several ways of appoaching it but generally there must be some rules or wisdom about what makes a function. Also, how do you decide what goes in the main game loop and what goes into a function. Your excellent responses have given me some good ideas !

Thanks

my game uses as few whiles/waits as possible.
Means:
Main-while-loop: every environment function that has to start every frame
Function-intern-while: every function with an other waittime than 1

And because nearly everything in an japano-rpg has the same waittime, the main-while is big ^^



Ps.: my scripts are organized itself.
From the script Top to the bottom
Name -> description -> functions -> actions -> mainloop

Defines and includes are in a seperated script (best overview above all scripts ^^)

I try to keep as close to polymorphistic as possible, as generic as possible and as object oriented as possible.

A few of my own rules coming to mind:
- Each function processes their gained data, and forgets about it.
- As few global variables as possible.
- Every object (structure + assigned function) manages the lower objects, and never vice versa.
- Never allocate memory and pass the pointer to higher objects. Instead, create the memory block on the level where you use it, and remove it there as well.
- Everything is managed by the game loop.

But there's much more to do in proper ways, using various techniques. Handling object states... using events... using observers, adapters, factories... I don't know the best way to do this stuff, but I'd gladly read a fifty page article about it all (not that 50 would be enough at all). Anyone up for a write?

When you say 'structure' do you mean structure as in C language or something within Lite-C like an entity (which is a kind of structure ?)

Thanks