Got the basis of a console in there…

Changelog

Engine (C++)

* Fixed up warnings about casting from one type to another...
+ Optimised drawing a bit more.
* Updated GWEN, fixed binding issues.
+ Added Program Icon

Game (Lua)

+ Added Console (Sortof... still needs work)
	* Console is embedded at the root level of the program.
+ Added Mod:GetComponents(race)
* Changed World spawn tick rate to 10 seconds
* Changed unitEntered to unit_entered for buildings

Busy with other stuff today, but did think about how to handle the UI that users interact with…

Now we’re starting to get somewhere

Turrets now work properly, and can damage units and destroy them.

Changelog
Game (Lua)

+ Implemented World:RemoveEntity ( entity )
+ Added "weapons" to mods...
+ Added class PlayerObject (All game objects that belong to a payer inherit from this)
+ Added class Projectile.
* Moved turret logic from Turret to TurretHardpoint.
+ Added action SelectedBuildingAction.
+ Turrets now recieve units that are alraedy in tiles they listen to when they are placed.
+ Improved var_dump a bit more (If passed a nil object, states that it's nil)

Today’s challenge is to get the turrets tracking properly, and getting them attacking. Unit attacking should be fairly straight forward as well (The ranged combat at least).

Chagelog
Engine (Lua)

+ Added Turret function 'basic_track_fire ( dt, hardpoint, target, cooldown )'
+ Added class TurretHardpoint.
+ Added a way of identifying units (uid).

Nearing crunch time!

I’m now keeping a list on the blog of the things that I need to get finished before I can say that the game is “complete”. The list can be found here.

The icon for the game also looks alright:

Today’s task is to get Turret’s identifying units, and then performing their actions based on what units are in the turrets detection area.

Units are now notifying the world when they move, which is storing their location in the container that the unit falls into.

Changelog:

Game (Lua)

+ Added more stuff to the Terran Sprite Sheet.
+ Player now get's passed the "race" they're playing as.
+ Added Player:GetRace()
+ Turrets now create/initalise their hardpoints.
+ Units now notify the world when they move.
+ The world now sorts units in "contianers" depending on their location.
+ When placing a turret, its hardpoints that have components on them are shown.
+ Added a helper class called Race

Engine (C++)

+ Changing the Z/Texture to the same Z/Texture on a crumb will no longer cause it to do any changes.
+ Cached a assets rotation (Instead of constantly building a rotation matrix for it)
* Started playing with an icon for the program.
+ When Crumb::Add is called, the crumb assumes ownership of the crumb that is being passed to it.
+ When Crumb::Remove is called, Lua takes ownership of the object.

Been playing around with an idea for an icon… might do something better though

Turrets are the main focus of today now, they’re getting there, but they’re sort-of like units, but not like units (They have hardpoints, but they are not modifiable like the units are).

The next challenge is to get them correctly identifying units, and then after that attacking them. One way or another

Changelog
Game (Lua)

* Separated the actions in ClientRenderer into seperate files (To make it easier to read...)
+ Split BuildBuildingAction into 2 classes (To make it easier to allow for new "building types")
+ Added Player:BuildTurret( x, y, data )
+ Added Turret (Which inherits from Building)
+ Added World:CreateTurret()
+ Improved the var_dump method.
* World no longer updates the texture if it doesn't change...

Engine (C++)

* Fixed up more little typos...

So, yesterday was more-or-less a bit of a miss… but today’s looking good!

Today’s work has been mainly on the path finding side of things. And sorting out the issues that are arising from that (Trying to make the system solve paths that have 3 states (Solid, Partially Solid and Empty)).

There’s been some slight work on the whole scripting of buildings, adding a new event that is passed to the building when a unit enters the building.

The default rule for a building that doesn’t specify what to do with a unit will be to simply move along to the next target (Either one the player specifies, or the default gate for the build zone (If there is one)).

Also starting to work on unit combat, and getting units attacking things (Unit v Buildings first, and then Unit v Unit). Ranged combat will be more easier than melee, but ranged introduces more complications (Such as prioritising what gets preference and whatnot).

Today’s changes also include the improvement of the rendering system to use batching. Currently, without any form of culling, the game is running the test map at ~200FPS.
The old rendering system ran at ~200 with culling.
Update: Running with “the quick and dirty” culling, it now runs at ~700FPS

I also locked down nested textures, they can no longer be different textures (To improve the batching speed). I might look at fixing this at a later date..

This is starting looking good

Changelog:
Game ( Lua )

+ Added config option for "Fullscreen Mode"
- Removed Renderer.lua (Since it's all done in C++ now)
+ Implemented a map loading system (MapLoader)
+ Added helper function for buildings called ( gate.route ( building, unit ) ) which sends units to the buildings defined targets.
+ Added Hardpoint:Update()
+ Added various functions to Unit
+ Added helper methods for loading resources.
+ More small changes that I've forgotten about...

Engine (C++)

* Started to play with batching draw calls (Sortof).
* Played around with the pathfinder.
	+ Fixed some things...
	- Broke some things...
- Removed dead code.
+ Implemented basic batching of objects.
	* Can still be improved in some regards.
+ Added more helper methods to the Matrix44 class.