game-editor.com

I had a huge thing written out then I accidently hit ctrl+r.....


I was wondering if anyone was interested in creating a Team to create Game Editors, Templates, Functions, and Designs, that can be used over multiple games and even design some original games.

The idea is that we become more organized with our projects and try to instead of individuals developing many mini-games, we work together to develop quality games.

Everyone is allowed to join the team. I am hoping that this would be an educational effort to help Beginners and Experienced alike to create more quality games, and use techniques that are portable over to other projects.

The team would develop quality games and tutorials to help others learn to use gE optimally as well as show off the abilities and minimize coding errors and downtime, avoiding bugs and creating optimal workarounds.

I am hesitant at only that many of you might not be interested, but if you are, I would hope to start creating some organization.

This team would improve game development by increasing speed of production, increasing quality of game play, increasing user knowledge spread, and improving gE all around.

To explain a little more how it would work..

The Team would use a Design Template Guide to create portable functions and code that could be used for many different games. Building fast editors that can change resources such as, but not limited to, tiles, sprites, and music. For games that use similar code. Creating Game Engines that can add features and change content, such as, but not limited to, story, characters, creatures, gui, and functions and features. For games such as, Platformers, Puzzles, Isometric, shooters, 3D, and more.

The team can be broken down into catagories of expertise such as, Game Design, Game Engine Development, Game Editor Development, Art, Sound and Music Creation, Testers, Tutorial and Commenting.

I hope some of you are interested. I have enjoyed this forum and using gE. I would like to develop and sell professional quality games using gE that could be used to improve the production of gE and its games.

This is a pretty good summary of what I had originally written.

I had something in the go before... http://dl.dropbox.com/u/9246426/tileeditor.exe
it uses a square image and outputs it as a perfect tilable ISO tile, the program is incomplete. +/- is to zoom in and out. I'd be interested to finish it if you find purpose in it!

I'd like to help, but I'm pretty sure I wouldn't be too much of that

Wow!! That tile editor is AMAZING!! That would be awesome to use!! Especially if you could make an entire scene out of the tiles with it.

Honestly, that would be extremely useful. Although, GIMP and other photo manipulation programs do all this just as well. I wouldn't want you to waste your efforts on something that can be done in another program that is already complete.

The tile editor would basically need to do everything a photo manipulation program can do, except be able to export the image into tiles, and allow to place tiles to make sure they line up.

So, while it would be an awesome little tool, I think it would take too much time away from more important or valuable programs you could make.

Great idea though.



Also, anyone who wants to be a part of the development team is already helping XD. Beginners could learn from the advanced material that the veterans would produce. Also, I am sure everyone here is developed enough to help in someway if they wish.

All games are pretty simple, its just the design of them is what makes them appear difficult, but once broken down into subjects and functionality it becomes more "viewable" you start to see the little pieces rather then the big picture. Thats why there is multiple teams. The design team, the big picture people, and the coding teams, the puzzle piece makers. Both of these teams can be of the same people but you separate the way you think about each subject.

Making games is like building a house with your bare hands, first you are going to need tools. First you design the house, then you design the tools, then you build the foundation, then you build the framework, then you put together all the little details that make the house a house, then the paint and polish.


First though, we need a committed team.

Second, we need a way for the team to get on the same page. A team project and team rules/coding guidelines, so we don't end up with conflicting code. A template that discusses variable naming schemes. Game Design Tools would be the best start.

Then we just start working on a project sharing code and trying to advance different sections of the same project.

Did I forgot to mention I was also going to develop a sort of loss-less compression method for pixel art? pictures will be stored in the 32x32 fashion, but will be displayed with my function (Without loosing a single pixel information) on the fly... But perhaps you are right. I wanted this program to be specific for tiles, and optimized in all the ways I could think of, but GE can't display pixel per pixel fast enough anyways... though in the future we should be able to (Makslane has plans for making GE runs faster!)

In my original plans this was for a sort of social game where a player could build their own tileset to create their own world (Hence the name GE World)
there would be editors for sprites and all, probably an action editor too to make objects come alive. A big project.

Code: Select all

void ISODraw(int xoff,int yoff,int TID)
{
    short unsigned int IMGB[63][32][3];
    int i,j;
    float k;
    for(i=0;i<32;i++)
    {
        for(j=0;j<32;j++)
        {
            IMGB[j+i][i][0]=TImg[TID][j][i][0];
            IMGB[j+i][i][1]=TImg[TID][j][i][1];
            IMGB[j+i][i][2]=TImg[TID][j][i][2];
        }
    }
    k=15;
    for(i=0;i<63;i++)
    {
        for(j=0;j<=((i<31)?i:62-i);j++)
        {
            setpen(IMGB[i][j+(int)max(0,i-31)][0],
                   IMGB[i][j+(int)max(0,i-31)][1],
                   IMGB[i][j+(int)max(0,i-31)][2],0,1);
            putpixel(i+xoff,j+(i>31?0:0)+(round(k)<0?abs(round(k+.5)):round(k))+yoff);
        }
        k-=.5;
    }
}

this is the code I used to transform 32x32 tiles to iso tiles... perhaps someone could optimize it more?

This sounds like fun, I can compose music and beta test. I would offer to code some too but you guys are quite a ways ahead of me at it is so I do not know how much help I'd be. As far as music and game testing though I can do those to a very high level. =D

so when's this thing going to start
I'd like to help with art

Well it can start now XD

First we need to create a sort of guide for designing. If you want to follow some of my already implemented ideas such as naming conventions then we can start right away.

Gag I love the idea! It sounds awesome, that is kind of like what I imagine my game to be like, where a lot of the game is user content. But I have a huge design and its a big project too. But the tools have to be constructed first.

I think the first thing to design is the world editor, basically a way to create maps. We can either start with a already in progress project or start fresh. Either way its a design that needs to be created first.

We need, also, some way to organize ourselves so that its not just a mess of code and content. Some way to distinguish the project content. I have been creating an ISO map editor but the issue right now with that is I have to redesign the whole thing basically. I mean it does what it should but it needs to be redone using linked lists and manageable structures.

I don't want to like tell you guys what to do or anything XD unless you want me to lead the project, I mean this was my idea but I don't think of it like that, this is a team building project and experiment to maybe get a game development team that can build games.

Please contribute any ideas you wish and we can see how to work them in and if you need help with anything please feel free to ask.

So, First, I guess... we have to decide what we should do?

My ideas are already available and as I said I have to redesign them to run fast and smoothly. If you want to help me on my current project that would be awesome, and if you have any project ideas, again, feel free to contribute.


My idea for a game/game template. Is an Isometric RPG adventure game, the world's are large, full of creatures, and many NPC's. The Player Characters have a stat system that is based on the actions of the players, if they are running and moving a lot, dodging and weaving, their dexterity will rise. If they carry lots of heavy equipment constantly their strength will rise, and so on. Skills and spells are leveled up based on training and use of the skill. There are many other factors involved too.

The first thing that I think should be created for designing such games is the world editor.

The world editor should allow for tile placement, object placement, and creature placement. Anytime we can substitute a set of tiles for an object, that will make the game that much faster because that's less actors the game has to handle. So the main focus is to use as minimal amount of tiles as possible but to also use the fastest displaying features of gE. I have made a system, that needs to be reworked to be even faster, that uses only enough actors to display the screen. It can allow for an endless map through linked lists. The first goal I have in mind is to create a world, a spherical map that has no end.

To explain Objects vs Tiles.. Anytime we can use a set of tiles for an object would be the fastest method, because an object means creating a new actor on top of the existing tiles. Objects allow for things like walls, trees, or rocks to become transparent as you walk behind them. If this game became multi-player, which I have an idea in mind for that as well, it would allow for one player to be hidden behind objects while other players try to look for them. In which they could use skills to locate the player. But we could also hide monsters and NPC's behind objects to surprise the player as they walk past.

The world editor should allow for instant play, to test the level design with a cookie cutter test character. So we can test to make sure things are sitting properly and functions are working correctly. But mostly the world editor would be used to create maps, dungeons, towns, or entire worlds. It needs to be multi-layered.

Layer 1: The Tile Layer
Layer 2: The Floating Tile Layer (similar to the object layer)
Layer 3: The Object Layer
Layer 4: The Creature Layer

This will allow a map to be built using minimal actors and will display properly. This will also allow for many game types to be created from platformers to top-down RTS's, to isometric RPG's, and more. The world editor must be made with all these game types in mind. As when you export the map to a file it can be used in a multitude of different engines.

About how the map would be saved. The map is stored as a single file of 2D character arrays for tiles. The arrays match the layers where the dimensions of the array are the x,y coordinates of the world nodes. Each value in the array is the animation index of the tile. For Object's and Creatures, these will be stored in unique structure arrays that have all the variables of the actor and the variables of the unique object or creature. These are stored in 1D arrays to keep them condensed and not have holes in the arrays.

If you have seen my map maker then you can see how the maps are generated. After a certain point in the animation index the tiles are considered unwalkable for use for path finding. There can be more than just 2 types of tiles, there can be unique tiles that do various things when stepped on such as cause affliction or slow. Tile sets will be used for each map, I believe the char datatype allows for 255 different unique tiles. For RTS's part of the set could be considered unbuildable. Tile sets will be unique to the game the world editor will be used to make. So the world editor supports tiles of various sizes as long as the dimensions are plugged in first.

Game Engine Templates: These need to be set up to use outside resource files such as .dat files that can be used to store things like equipables, consumables, spells, skills, story, dialog, and various other content based things. Content cannot be hard-coded into the engines, but set up to use a set of rules and functions to allow for content to be implemented. The things that are hard coded into the game are, movement, AI types, displaying of maps, getting input, allocating and freeing memory, anything needed that isn't content based.

Game GUI/HUD Editor: This allows for games to create GUI's and HUD's for their games. This is things like, Energy bars, Showing currently selected Actors, Buttons, Menus, Inventory, ect. Giving ready tested functions to use and quick adding of items such as mini-windows with scroll bars, buttons, form boxes, text boxes, ect.

Sprite and Animation Editor

Tile Editor (Game A Gogo's)

Music and Sound manipulator (if possible)

I can think of more stuff but I figure that is a good amount to explain what this team will be handling. Basically creating easy to use tools for game creation. Creating these tools can then be used to create games faster and we can design many games and try to go for professional quality.


And for anyone interested in my current project which is the world editor, here is the most recent version. This one does not include linked lists as of yet. I still have a lot to do for it, but as you can see my art is lacking, although that isn't my main concern at the moment.

World Editor Design:

Tile Actors:

Using minimal amount of tile actors to fill the screen, the tiles move from the back edge to the front edge of the direction the player is moving.

All the tiles must be linked together in a linked list, linking x->x, and y->y. So that when the tile moves from the back to the front it is replaced by the next tile for quick access and fast swapping. Each tile structure holds at least four pointers and at least 1 value.(clonename) The four pointers point to the previous x tile, the next x tile, the previous y tile, and the next y tile.

Seperate pointers hold the address of the tiles to start at around the edges so when the move() function is called the tiles in order will be moved. Corner tiles have to be handled differently if the movement is diagonal or the pointer will be locked. This can be a good or bad thing depending on how it's handled. If we let one row handle the corner and let the other row start ahead of the corner then it will move both x and y rows to the proper positions.

After the rows move their animations must be changed and any values must be changed accordingly. This would get the tile from the world map and change the viewable tiles accordingly. Making the appearence that the movement is seemless and that the viewable map is larger than it appears.


Floating Tile Layer:

The game needs a floating tile layer. This layer is a hybrid Tile/Object layer in which tiles float over the surface of floor tiles and their transparency changes as the player moves behind them. This allows for walls and corners to seemelessly fade and makes the appearance of a standing wall. Also, this layer can be used to hide passages in the wall and the player would have to walk into them to find their existence.


Object Layer:

This is the layer for trees, rocks, buildings, loot, and various other objects. These can also be placed on the Tile Layer if the player should not be able to gain access behind them. This allows for less actors and faster game play. These actors as well as those of the floating tile layer are stored off the viewable map for quick access or created as needed. It should be noted that creation of objects should be done incrementally and not all at once, they should slowly increase as needed and be destroyed as their use fades. Objects should never have to be created on the fly or it will slow the game down.


Creature Layer:

Like the object layer, but holds creatures. This and the Object layer are linked lists with variables based on a structure template. They are handled just like objects except they have AI and move on their own will and have a rule set for them as well. Creatures should not be destroyed after use but instead moved to a holding array and their variables reset and ready to be placed back into action as needed to minimize lag from create/destroy calls.



The GUI for the World Editor:

Should have access to various tools including scalable tile brushes, Tile Object Brushes (These are objects that are made from tiles), Object brushes (to place more that one object at a time), Creature Brushes. A scrollable selection for Tiles. A menu for object editing and selection, (editing variables such as isDestructable, health, hardness, triggered events, and more). A menu for Creature Editing and selection.

A top bar menu for saving, loading, exiting, help, and other options.

A View Window for scrolling around the viewable map, and map editing.

A message updater, displays activity messages based on events occuring with the editor.


This is all I could think of for this... Anyone who wants to help me with this project just post and we can get organized.

I would like everyone who wants to help to just take initiative and lets start building a team. The only thing you have to do is make it known what you are doing and supply efforts to completing a task.

For art this just means creating/supply generic world/dungeon art, creating supplying preferably 3D iso models of quality, this can be done simplest with a 3D modeler. If you can make them look realistic and still keep it low resolution then that is best.

Anyone who can create a sprite pixel shader or can create a lighting engine for 2D games would be awesome.

Don't worry if you can't make it in a day or a week, there is always room for development. This is an educational project but to also help develop gE as a more polished game maker than people expect. Hope to bring in more community members and possible revenue. The faster we can get gE developed the better the games we can create will be.

Triple post Xd

But a lot of info passed so this is my last one for a while. I am going to start working on the World Editor, changing up my code to use linked lists combined with pointer arrays. This will give the best of both worlds allowing for fast direct access to the node and allowing for a linked list. Also, swapping pointers is faster than swapping large values, even in an array.

Here is how I am planning the structure:

Code: Select all

//Structures
typedef struct WorldNode{
    double wn_GameX;
    double wn_GameY;
    int wn_NodeX;
    int wn_NodeY;
    int wn_NodeID;
    struct Tile *wn_pTile;
    struct FloatingTile *wn_pFTILE;
    struct Creature *wn_pCreature;
    struct Object *wn_pObject;
    struct WorldNode *wn_pPrevYNode;
    struct WorldNode *wn_pNextYNode;
    struct WorldNode *wn_pPrevXNode;
    struct WorldNode *wn_pNextXNode;
}WorldNode;

typedef struct Tile{
    int t_Anim;
    int t_Unique;

WorldNode *** worldNodeArray  (2D Array)

Tile *** tileArray   (2D Array)

FloatingTile ** floatingTileArray (1D Array)

Object ** objectArray (1D Array)

Creature ** creatureArray (1D Array)



I believe this will allow for the fastest access times and easiest use. The only thing is to be careful about accessing pointers and initializing them before I call them. I don't think I will ever have to 0 them out because I won't be freeing any of the structures until the game is finished, I can just reset their variables to equal anything I need.

Generally speaking it doesn't sound like you are trying to make quality games, but rather tools to make quality games. It's a grand idea, but generally speaking you are just creating another level of interface for people to make their games through. And through that it is your hope for rapid production of quality games. The thing is, isn't that kind of what gE already is? I guess creating a second level away from the programming of the game could help the design process, but it does narrow the types of games you can make easily. I'm all for group projects and the like, but have never really liked the idea of building an rpg maker (for example) in gameEditor. I think my main concern with your project is that to use it, you'll need to learn a whole different design process, so using it will be different from using gE. It can and will however be a great learning experience for a lot of the users here. Another concern with a group project of this scale is coding standards. One thing that'll most likely need to be done is submitting function specs, otherwise a lot of the work won't be able to be split. I was actually going to try to start a forum project in a week or two (whenever I stop being sick), that wasn't quite as ambitious, but has a similar feel.

I understand what you are saying, but mostly the tools, well the first set of tools are not going to be used to create the game, or an RPG maker exactly.

The world editor is merely a tool to generate maps and levels for games. The actually game design and engine design is done using gE. The tools are necessary to be able to produce the mass content needed to create the games. While gE is nice it doesn't have an ability to produce massive maps, or for that matter, maps at all without trying to place actors piece by piece by hand. It works better for designing an engine and developing game structure and rules. It even makes it easy to set up controls. But you still need the other tools on top of that to produce quality in a timely fashion. Such as a sprite editor, a level editor, sound production tools, and tile editor, possibly more.

Also the way I want to design the world editor isn't just for Isometric games, its to create levels for any game. Just make them faster with bulk tile laying, and placing of objects and creatures. Instead of laying one coin at a time, I want a feature that lays a stream of them, at set intervals, just by dragging the mouse.

As for the coding standards, that's one of the issues that I was dreading as well. It will take writing up a standard for naming variables and main functions that will be used to link the pieces.

But once the tools are finished then its as easy as thinking up a game, then creating the engine in gE, creating the levels in a World Editor, creating the sound and music elsewhere, and sprites and tiles with an imaging program. Then use gE to link all the pieces together.

I mean, you wouldn't try to make a game using only an Unreal Script editor without a 3D Modeler and Level designer. It just would take too long, the tools are for the bulk resources while the game editor is for the fine tuning as well as main features and actual programming.

This is really just I want to see if anyone is willing to try to create a team for designing. Nothing here is set in stone, I am just throwing out ideas and still working on my tools.

There is no actual project here yet. Just trying to pull people together and see who can do what and who is interested.

I have an idea for you tile layer, duplicate it. One will be invisible to the player.
Why? So you can remove collision check on your visible tile layer, making the game faster!
But what about collision... That's what the invisible layer will server for, so you don't need to create empty spaces, as empty spaces already exist!
Plus it could allow for special tiles, like one that say, would push a player forward and all, without using objects which leaves you more control over the 255 tileset you have for visual!
Remember that tiles will have to be drawn with a canvas if you are going to use my tile editor, as that's mostly the only way to allow for user content to be inserted, unless we use it for developer only and have it export ISO tiles. Which I believe would be better, considering the lack of power GE has at the moment for drawing pixel by pixel on canvases. You'd typically would need a resolution of 320x240 or lower if you'd want something even barely playable... unless maybe we make several canvas actor, so when you move a tile, you don't need to draw it every frame...

As of your concern Sky, it's understandable. But it could also show the raw power of Game Editor to the public. Not many game design tools I know of are as raw and powerful in flexibility as GE, and to narrow that flexibility down you'd need to make use of it, which is essentially what we could be doing!

Evan, you'll have to enlighten me with linked list, I understand what they are, but they are still ominous to me!

We also might want to start a dropbox shared folder so all of our work get's updated in one place and in real time!

Great ideas. Although my system doesn't use collision checks at all It checks nodes and direction.

To explain, everything in the game is measured to be a specific height and width so that it fits. This is actually very easy and all the sprites will have size catagories. T^s T= is the constant tile size height and width, s is the size catagory, for smaller sprites -s for larger sprites +s, and this will only be necessary for the artist to understand as when the sprites are finished they only need to be set up so thay we know how many nodes they take up by ((T^s)/(T/2))

This method makes it were collison detection is based on if the node is blocked, is in adjacent node, or occupies the same node, respective to the action.

Example:

0 = blocked

Code: Select all

0, 0, 0, 0
0, 1, 1, 0
0, 1, 1, 0
0, 0, 0, 0


The player can only move to 1,1; 1,2; 2,1; 2,2; Not because the player is colliding with an object, but simply because to the computer that spot cannot occupy anything, unless we specifically put it there.

If a creature comes in and occupies 2,2 then that value goes from 1 to 0 and becomes blocked.

For increasing/decreasing speed its just a matter of checking the value of the node and multiplying it by the speed of the creature/player.


Linked Lists are pretty simple. Its a user created structure that has a value and a pointer. The pointer points to the next value in the linked list.

You have to link the list yourself, and create functions for handling the list. But there are many already designed that can be used. I wrote about them and put an example here in the useful functions. viewtopic.php?t=11159&p=77564#p77564

But they can be used in place of checking if a node is blocked simply by setting pointers to that position to null until it becomes free again.

There are a lot of things to be handled when using pointers though but they can be used to our advantage of speed. Sometimes two calls try to access the same space in memory, but only one can access it at a time. So if enemy 1 is moving through the linked list and has locked a node, and another enemy tries to access that same node it will return null and we need to handle that by If(pointer == NULL) try to find a new path, or wait until that spot is free to access.

Where the If is usually a for loop iterating through a path.

As for checking other things such as ranged attacks, they are placed into the object layer and when they occupy an area with a creature it deals damage to that creature as well as any additional effects.

The method I purpose will have absolutely no empty space, the object layer stacks objects tightly in a 1D array. But the array is only an array of pointers to the structures. The structures themselves can be created dynamically through the linked list, that's why I purpose an Array/Linked List hybrid is because an array allows for random access at the same rate while a linked list allows for faster manipulation of memory and sorting. Because when we want an object at the top of the stack we don't shift around objects in the array, we just change the what the pointers point too.

About graphical nodes, when using animations and moving objects around usually you do this in pixels per frame. The only issue is, often you are calling the same problem twice, basically, "move forward 3 pixels-> advance image 3 pixels" People don't even see half the movements made because it happens so fast, but the CPU notices it. It has to calculate the same problem multiple times just for one movement. With graphical nodes you set a position to be the center of where the image needs to go. So its while not at the node, keep going. Also it allows for forward intuition. Instead of, going until collision with pixel area; Its, check to see if I can go there, if not stay where I am. Where the former would have to make multiple moves until it found out that it can't go any further, the latter knows it can't go any further without actually hitting a physical wall.

As for the walls, they are using the original tileset with a couple halftiles to create corners. This way the wall can become semi-transparent and the player sees the wall still but can see his position behind it.

A lot of my ideas for this come from playing Diablo 1. I practically want to rebuild that game from scratch and enhance it a lot. Nodes will also allow for random maps. Where rooms connect by entrance nodes.

As for the tiles themselves. I would like to be able to have it where the map editor and game can link to an outside resource folder (if this is possible) rather then compiling all the images into the exe. It would be nice to use the canvas for tiles but I think for now we should just stick to .png files for animations and images. The floating layer is often going to only hold a fraction of the tiles that the tile layer has. This layer is also going to be used to allow for players to enter buildings and go behind them.

The tile set, while we COULD use a char array, we could just keep an int array, even though its quite larger it will allow for many many more tiles. Besides, with newer computers they have enough storage for a 4,000,000 int array. I did it from ram and it didn't cause a problem at all. If we were porting to mobile devices then we can modify it to use a char array with smaller maps and limited tile sets.

Pretty much these methods are almost "cheating" we don't want to make the computer do or think more than it has too. When it comes time to implement AI, we want as much cpu power as possible and making it as easy as possible for the AI to do its job of finding and eliminating the player, or in most cases finding and dying for the player.

But for now, my goal is to just build a map. One that a player can walk through and even with no AI, no Story, almost no content, can still enjoy the intensity and vastness with minimal processing power. The map could start off as a simple exploration game where you are a simple player that just walks through the world and discovers the new places, exploring the environmental dangers and puzzles of the map. Then when we can get a simple Attack AI and a more defined player it gets more interesting.

One of my goal games is called "Endless Dungeon" You create a player and start to explore the first level of the dungeon, fighting weak monsters and solving simple puzzles. But as you go deeper into the dungeon, the monsters get harder, the puzzles get harder, the maze of the dungeon gets larger. No two endless dungeons are the same. They are all randomly generated and once you enter, there is no going back. At various intervals of the levels until a point, there is a shop level, where you can go to repair armor, buy new armor and weapons, buy potions and other consumables. But soon the shops end, and all that is left is the endless dungeon. You have to pick and choose your loot. Which spare armor piece do you keep, what spare weapons to hold, of the variety of potions: do you keep the larger stronger potions even though you have less of them, or do you keep the smaller weaker potions because you have many.. Your armor is looking rusty and acid jelly's just ate your sword.. What kind of weapons to use, what skills to learn, what spells to invest time training. All of these become factors as you delve deeper into the "Endless Dungeon".

I think this whole thing is a great idea and I would love to get involved

@Evan: If you would like, I could try to improve and add to the tiles in your map maker. For a start
Would you like me to try?