XYG Studio [Game Development Kit]

[Kelvin]

eXperience Your Game

What is it?
XYG Studio is a runtime-based game development kit that uses SDL and the Squirrel scripting language. When it is done, the editor will run on Windows, Mac, Linux, Open Pandora, and Pyra. The runtime environment itself will be open-source, allowing it to be ported onto any platform, and even rewritten to run using different languages (it's being written in C++, but could be rewritten in C# for XBox or Java for browsers and whatnot). It can even be rewritten to work with other graphics APIs like SFML, OpenGL, SDL2, etc. so it'll work on virtually any platform.


What does it do?
The editor aims to feel as much like Game Maker's as possible while addressing a few issues and adding a bit more control to the way the game works. Although the game structure will be different, the required skill level will be about the same. Rather than mislead users by saying they can make a game without a single line of code (action icons follow the same logic as code, so they're really the same, just with different presentation), the included tutorials will teach how to code in Squirrel while building a game from the ground up.

Some issues found in Game Maker include things like always-on code that does not always do as the developer wants, and causes bloat and overhead when circumvented. XYG solves this by being as minimalistic as possible. Actors, the objects that are placed in a map via the level editor, will only start out with the most essential variables, and leave everything else to the developer to define (i.e. gravity, speed, direction, etc.). Components are like actors, but they have no physical body, so variables like x, y, sprite, shape, etc. are free to be redefined.

The room editor is split into two: a map editor and a level editor. The map editor is just for tiles and solid geometry. The level editor is where actors and components are placed, allowing multiple levels to use the same map. For instance, houses could share a common design and just use different characters to live in them, so recycling maps becomes an effective means of saving file space.

How much will it cost?
Nothing. You don't even need to pay for a license to make commercial games. You are, however, allowed to redistribute it, so long as you don't try to sell the editor or runtime. The project will be entirely donation-funded.

How do exports work?
Games can be exported by building a .xyg file that the runtime will open and play from. This file contains the game's resources and game-specific code, but does not include the standard code found in the editor; the runtime provides this to help trim down file size. If you're worried about players not having the runtime installed or that a new version may make your game unplayable, simply distribute the required version with your game. The editor will feature an option to create a batch/shell file to handle launching your game for you, so you don't have to reassociate with the old version every time you want to play your game.

Can I help?
The code has not been released yet. I'll post a link as soon as it's up.



Currently, the runtime is stable. I'd been having trouble with a few things earlier, but that's all fixed, so I'm progressing once again. The sprite class is working beautifully, and even cleans itself up at the end of execution. The RE also produces a log file that lists events and their time of execution. Shape classes are almost done. I'm working on using the separating axis theorem for hit detection, since it looks fast and reliable. Keyboard controls are working perfectly now, and I'll be working on the map editor after I've done hit testing. Essentially, I'm doing it in this order:

*Graphics
*Keyboard
*Collision
*Files
*Maps
*Levels
*Scripting
*Joystick
*Sound
*Networking

The editor will be written in Qt, and I'll start that once I've gotten maps implemented. Oh, also, levels will be able to have their own variables as well.

Change log:

Spoiler

V 0.0.7:
~Fixed all graphics glitches. Sprite rotation and pivot position now match up perfectly.
~Fixed all input glitches. Key release checks now work properly.
~Rewrote collision code to be faster and more simple.
~Removed string input handling. String input methods vary from game to game, so it's better to let users define how this works.

V 0.0.6:
~Created new class xyShape as parent for all shape classes.
~Hit test functions have been merged into a single function.
~Hit test can now be called through the shape instance.
~Temporarily removed support for OpenGL.

V 0.0.5:
~Merged window, string input and camera classes into a single game engine class.
~Added linked list to sprite class for data management and endgame cleanup.
~Turned shape structures into classes and rewrote hit test functions to fit.
~Revised most of the library so it's more organized.
~Removed Box2D for the time being.

V 0.0.4:
~Created sprite class.

V 0.0.3:
~Included Box2D.
~Created camera class.
~Organized functions into separate files.
~Created a function that flips an image.
~Included SPriG.

V 0.0.2:
~Added function to force a bit depth on loaded images.
~Turned vector structure into a class.
~Deleted vector-related functions and made better versions in the class.

V 0.0.1:
~Added basic graphics functions, shape handling, basic collision, and window class.
~Started actor and block classes.
~Actor class is complete enough to be useful.
~Image load functions include options to preserve or optimize file format.