== .plan file description ==

This is a devlog/changelog of sorts. Each day of development begins with a new section.

Additions to the game are marked with a +, - denotes a removed line.

* is used when a bug has been fixed.

? is used when a bug has been discovered.

~ is something that must be amended/added soon.

Order of entries is sorted descending from most recent to earliest.

== 25/01/2014 ==

~~ 01:27PM

Haven't updated the PLAN file in a long time. Haven't worked on the game in a long time either, so I

guess that's reasonable.

Let's see… recap… Last time I worked on Exile was last March. That's nearly a full year ago, so

there is no doubt a lot of stuff I was intending to do last time that I need to do here…

** READS REST OF PLAN FILE **

Ah, this was the pre-loss project plan. To document the event, in around March/April 2013, I lost

the Exile development folder and was left with a beta release that I had let a few people try out

on my Dropbox account.

This was the version where I had added multi-layered maps, decreased the multiplier for height

offsets, decals and a hand-rolled script system for maps.

This was all lost. In around July/August I picked up the old version of the engine and basically

wiped all previous changes to the engine in preparation for the 7DFPS jam, which I decided to

enter with a simple game called "Abyss". This was going to be somewhat of a 3D First Person

Rogue game, but turned out to be a glorified level editor.

The engine gained an integrated level editor with support only or a single layer of map,

but added walls, ceilings, floors, height offsets for all of these and lights.

Also added was the concept of an EEnt, or Editor Entity. This is part of the spawn system

that allows for dynamic entity spawning without anything having to be hard-coded or any

ridiculous if/else chains.

The lighting in the engine was improved drastically; that is, there is now lighting as

opposed to the color blending that was done in Exile 1.4.

A proper per-pixel lighting shader has been implemented, and an unlimited number of

lightsources are now possible. Additionally, these lightsources can move.

Yet another change was the addition of Line/Line intersect testing for some collision.

This makes collision with walls smoother, and allows me to have walls that are represented

as lines within the editor, instead of actually using a whole tile position.

Height offsets affect collision, as an aside, so ledges and such are possible.

On another front, gamepad support has been added (And tested).

The asset system has received a general overhaul; almost all assets can be referenced by

name instead of an implied index (Which would lead to crashes or graphical glitches).

One last task to perform with regards to this is to allow each map to build a tile index

that references tiles by name and assigns a -local- index to those names; this'll do something

I should've done a long time ago: Render the order in which tiles/textures are loaded completely

inconsequential.

Back to the map system, the format has been left open in order to allow for additional data to be added

relatively easily. The format is a headerless binary file, organized into the following sections:

* Floors (12 bytes per space. TileIndex, Height, Metadata)

* Walls (12 bytes per space. TileIndex, Type, Metadata)

* Ceilings (12 bytes per space. TileIndex, Height, Metadata)

* Entities (12 bytes per space. EntIndex, Height, Metadata)

* Lights (4 bytes, LightLevel)

Each map has a constant size, so the filesize of a map will always be very close to any other.

The current constant size is 1024x1024 tiles, which is larger than the largest old Exile map, and

with better access performance.

The filesize is relatively low, averaging at around 832kb. This will grow as new map sections are added,

and when the named tile/entity indices are implemented, but this is negligible (As long as each map is

roughly < 16MB, I'm happy. Also, some RLE compression can be used to compress all 'empty' or similar sections

of a map, reducing the filesize by a large degree).

Now that I've more or less finalized the structure, I need to add a simple header system, and must section

code off to allow for expansion (Use load_v1(), load_v2(), etc for different map versions).

Additional sections I want to add:

* Floor Decal (12 bytes, DecalIndex, Type, Metadata)

* Ceiling Decal (12 bytes, DecalIndex, Type, Metadata)

* Wall Decal (12 bytes, DecalIndex, Rotation, Metadata)

* Trigger (12 bytes. Type, Meta1, Meta2)

In addition to this, I eventually want to add multiple layers to the map format. For this, a table in the

header will be used. It'll work something like this:

NUM ENTRIES

ENTRY 1 - File Offset

ENTRY 2 - File Offset

…

ENTRY n

This isn't an immediate problem though; for now, a sense of height can be fudged by using teleport zones.

Moving on, the next major addition is the change to the scripting system. In the original 1.5/1.4, I had

rolled my own archaic scripting system that operated specifically on the map.

In this version, I have integrated LUA, and have introduced the ScriptedEntity. You add these with

the assets.dat file, which adds them to the spawn list. If you add a corresponding EEnt, it'll add

them to the editor too.

I'm in the middle of opening up as much of the engine API as necessary to the LUA scripts, allowing

for a lot to be done. As soon as I have the necessary components ready, I'm going to reimplement the

player code in LUA.

Additionally, I must add a LUA state to the Map type, to allow for map initialization scripts.

Well, that's enough of a recap. Back to work.

- A lot of things

+ A lot of better things

* Quite a few things

? Basically everything

~ Should actually start making the game.