For lack of time to implement something more comprehensive, Shard uses this API.

Because of the way this API works, these issues can appear, sometimes all at once:

• Units are spaced apart by large distances
• Maps are built in such a way that those large distances prevent a position being found in the search radius
• Wide open plains are ignored because they aren’t inside the search radius
• A builder in the middle of an island might not have any valid water in its radius when requesting a shipyard
• Units are built too close to each other

These are symptomatic of how the API works.

Closestbuildsite requires a position, a radius, a unit definition, a facing direction and a spacing parameter, but has the following problems:

• If you pass the builders position, you will likely get the builders position back, and the builder will block itself, preventing construction
• As the search radius goes up, the cost and performance degradation rises exponentially, it performs no caching, and employs no special mechanisms to optimise
• The spacing parameter is counter intuitive. The unit of measurement is how footprints worth of the specified unit
• Spacing doesn’t take account of terrain or units, anything that blocks counts, so if there’s a buildable area with a small bump in the middle, it will not be valid.

So if we specify a spacing value of 5, and build a light laser tower with a footprint of 1, it must be 5 from the nearest unbuildable square. If we build a kbot factory with a footprint of 8, and a spacing of 5, it must be 40 squares away from any unbuildable blocked position.

Shard attempts to mitigate this by doing some math on the footprint values and giving different values as spacing depending on how big or small a footprint is, but they’re approximate, and hard to optimise. Failures are inevitable. You can use the API to pass in your own position, but few do, and it moves the optimisation of spacing issue to lua rather than the C++ component.

So What’s The Longterm fix?

Implement a building placement algorithm. Possible mechanisms include:

• Brute force test each square, starting at a position and radiating outwards ( expensive )
• Split the map up into a grid, and mark larger grid squares as free or not free, with data on wether they’re valid for unit types. Generate valid positions ahead of time

I will likely take the latter approach, and I’m sure there are other routes, but those are simple and easy to implement, and importantly, to expand on for each games purposes. In the future it also leads to basic landmass detection using a basic flood algorithm, to help prevent things such as shipyards in ponds, land factories on islands, and other silly construction decisions.

It could also be a good idea to delete the method from the API. This may break some old AIs, but most encountered this issue and built their own algorithm. Doing this would prevent new developers falling into the same trap and force new algorithms to be built ( and more clever AI features )

- Lead image source: http://www.flickr.com/photos/metrolibraryarchive/4128220971/sizes/o/

It appears the spring community is now hosted on a very expensive customised espresso machine:

Asked about the new machines specification, the owner, Licho had this to say:

15:36:39] <Licho[0K]> yeah something like that .. its 24gb server in roubaix france ..
[15:37:09] <AF> is it noisy when it's at work?
[15:37:31] <Licho[0K]> most likely yeah, it has ordinary disk and fans
[15:37:47] <AF> aha a custom build ^_^

Previous servers include Fnordias much lauded media TV, and its replacement, the infamous internet enabled fridge. We asked numerous community members their opinion on the output of the new espresso machine:

[15:54:34] <[LCC]KingRaptor[0K]> things seem a bit smoother (may be placebo-like effect)

Rival bidder for the new machine tender  Paro Robots U.S. Inc. is said to be angry at the revelation.  Paro Robots had proposed the internet enabled cuddly seal:

Upon light of the rejection, rumours of an impending army of angry Japanese investors displaced rumours of the impending army of Atari litigators. The community is expected to return to Atari fear-mongering in the near future.

To start, Foreboding Angel has offered to lead a port of Shard to exist as a pure lua AI in the spring engine, using the native gadget AI APIs.

How will the different projects move forward?

I will continue to develop Shard as ‘Shard Core’, using the native interface. Foreboding Angel will lead the maintenance of the Gagdte Port of the Shard API. The Shard code from SHard core will use this API, and only this API, to ensure compatability.

Naming

My build will be termed Shard Core, and I suggest the following naming scheme:

<game name or distribution name> Shard <version moniker>

e.g. EvoRTS Shard Ballsey or just EvoRTS Shard if we were to take the latest release ( 0.31 Ballsey ) and the gadget AI currently used in EvolutionRTS.

What is Needed to Port the API?

Shards C++ component exposes an object called game_engine which is wrapped by another object named game in the file api.lua. Using this, one can make this objects functions work in both environments.

E.g. to make the game:SendToConsole call work in both Spring and Shards lua environments, the following ammendments need to be made:

   -- prints 'message' to ingame chat console
   function game:SendToConsole(message)
      if Spring ~= nil then
         return Spring.SendMessage(message)
      else
         return game_engine:SendToConsole(message)
      end
   end

From here on it’s mainly a matter of including the new api.lua, the ai itself, instantiating an instance of the AI from a gadget luaAI, and then passing events to this new AI object. Wrapper wills also need ot be made to prepresent the unit objects and unit definition objects also, but these are simple and would require little work, and can be done entirely using spring gadget API calls.

Spring specific code?

Once Shard is ported, developers will want to use their own code callouts and access spring specific APIs. I ask that rather than modify the existing code, they duplicate the relevant behaviours under a new game specific name, and make their own adjustments there. This way they can retain the benefits of updated Shard code, while having their own code that integrates with their own gadgets. Further documentation and helper methods will be made available to facilitate this, allowing Shard behaviours to be added from other spring gadgets.

Progress

Foreboding is currently refamiliarising himself with Shards internals. Here’s a video of a recent battle he posted:

It has been found that there was a typographical error ( a missing ‘=’ ). Fixed in the development build it has gone unfixed in the latest release, but not any more.

Download Shard 0.31.1 Not So Ballsey here

[20:19:31] <[Mr]Peanus_Butter> yo its #fhh£hu@4545, just a few questions about shard if you've a moment
[20:19:41]  oh rly?
[20:20:10] <[Mr]Peanus_Butter> i'm wondering how shard determines threats or enemy positions... how does it choose how to attack basically
[20:20:27] <[Mr]Peanus_Butter> i know it waits until a certain number of units are massed
[20:20:33] <[Mr]Peanus_Butter> but how does it decide where to go?
[20:20:37]  the files in question are attackhandler.lua and attackerbehaviour.lua
[20:20:46] <[Mr]Peanus_Butter> just a sec, i make open
[20:20:55]  when the unit is built
[20:21:07]  behaviourfactory looks at the behaviours table and loads the ones specified
[20:21:13]  if no entry is found
[20:21:25]  it looks to see if the unit is in the attackerslist table
[20:21:32]  and adds the attackerbehaviour
[20:21:45]  the attackerbehaviour then acts kind of like a conscripted soldier at home
[20:21:58]  it fires off an event registering its presence to the attackhandler
[20:22:09]  attackhandler then saves it in a table and does a check
[20:22:23]  if the queue of waiting attackers in the list is above a threshold
[20:22:28]  it removes them from the queue
[20:22:36]  and starts looking for a target
[20:22:48]  it iterates through every enemy on the map
[20:22:55] <[Mr]Peanus_Butter> ok i'm going to need a DL link, apparently i havent got it on this computer
[20:22:59]  adding its position to a counter on a grid
[20:23:08] <[Mr]Peanus_Butter> (still listening, thx for this)
[20:23:23]  when all the units are categorised, it picks the grid sector with the lowest nonzero value
[20:23:45]  this is how AAI, and NTai chose their targets
[20:23:53]  only AAI and NTai chose the highest
[20:23:56]  not the lowest
[20:24:02]  NTai had a lot of other twists also
[20:24:04] <[Mr]Peanus_Butter> so the choice of area to send attackers to is -not- actually using a threatmap, but a similar behavior, looking for a weak point
[20:24:24]  those 2 AIs did the targeting loop every few frames and added it to a heatmap that decayed
[20:24:34]  its more instantaneous and reactive
[20:24:37]  no lingering threats
[20:24:45]  rather simple if I do say so
[20:24:53]  when an enemy target is found
[20:25:01] <[Mr]Peanus_Butter> hmmmm
[20:25:04]  the attackhandler orders the attackerbehaviour to attack
[20:25:13]  a fight command is sent to the position
[20:25:20]  and the attacker is now left ot its own devices
[20:25:27]  and si out of the loop
[20:25:43]  when the attackerbehaviour recieves a unitIdle event for the attacker
[20:25:52]  the assumption is that there is nothing for it to do
[20:26:01]  so it assigns the attacker as in waiting
[20:26:08]  and repeats the whole process from the beginning
[20:26:23] <[Mr]Peanus_Butter> well it sounds pretty efficient
[20:26:23]  a nice and simple 'new' unit goes in
[20:26:26]  attacker comes out
[20:26:53] <[Mr]Peanus_Butter> attacking a weakpoint seems like a better strategy than attacking the strongest point
[20:26:58]  I have further optimisations to make to the algorithm to make it pluggable
[20:27:13]  you have IK to thank for that insight
[20:27:15]  but
[20:27:23]  I intend to make it a choice in future
[20:27:27]  like supcom
[20:27:33]  cull weakest vs attack strongest
[20:28:22]  do you mind if I repost this as a blog post?
[20:28:41] <[Mr]Peanus_Butter> yeah for sure; its helpful knowing how it works
[20:29:15] <[Mr]Peanus_Butter> i'm playing with a survival game idea with car and bob and wombat and a few others; trying to learn what i can about the various AI behaviours in spring
[20:29:26]  note
[20:29:31]  that the entire attacking system can be either
[20:29:33]  sidestepped
[20:29:35]  or replaced
[20:29:53]  all it would take is either your own behaviours, thats then assigned to attacker units
[20:29:54]  or
[20:30:05] <[Mr]Peanus_Butter> the other day I was testing shard against some other AI I've forgotten which and noticed the difference in attacking weak vs strong; i attributed it to a difference in threatmapping, but now i am wiser
[20:30:07]  put your own attackerhandler and attackbehaviour in your games subfolder
[20:30:21]  Shards Lua VM is set to ignore the main files if one is present in a game subdir
[20:30:29]  so itll be as if ym implementation never existed
[20:30:55]  or you can have different units use differing attack systems

Job & Moving Flat

I’m currently working as a Web Developer at QuadroNation, and moving flat, which has taken up quite a lot of my time the last few months. I now have keys and a move in date! So the disruption should lessen soon and I can get back to work on my projects.

Shard

Work on .32 is going slowly. I have made improvements and fixes for fringe cases, but I have made no release due to a handful of problems that I’ve found in new games with the new code. Suffice to say I am behind schedule!

This Website

Since my last blogpost on Darkstars development, Ive made quite a few changes. However I’ve decided that I need a site attributable to me by name, one that doesn’t have people scratching their heads figuring out how to spell my email address. So I’ve been working on a second site to showcase me as a Web Developer, which is coming along nicely. I’ll then backport the changes into darkstars.co.uk

Stamper

Others will have noticed a lot of changes to the Stamper tool, from PNG images, to improved quality and multiple logo support! Go check it out here.

• Spring v0.82.6.1 support
• Dramatically improved performance when searching for construction sites, spikes should no longer occur
• Shard will now search in a much larger radius for geothermal construction sites ( 600 -> 3000 )
• Shard now staggers the search radius and spacing of construction sites based on the size of the unit that needs building
• Internal Architecture changes to support logic modules
• Spike timer messages are now disabled at runtime
• Code layout of default taskqueues changed to encourage better practises for newcomers

Download here

• Factories no longer search for build position wasting cpu time
• Builders are only allowed to move on to a new task one at a time each frame, and will wait up to 10 frames for a free slot before executing their orders anyway to prevent clogging up the internal systems
• Minor optimizations for extreme cases
• Basic Conflict Terra gameplay support
• Debug timers for detecting spikes ( uncomment in ai.lua )
• Spring 0.82 fixes

These changes should greatly improve performance, and fix Shard under the latest spring release, however there are still momentary spikes in late game. These issues are being worked on. While I reduced these spikes in 0.3, they are still present and I do have ideas on how to smooth things out.

Download here

Lets start with vastly improved Evolution RTS gameplay. Working with Foreboding Angel, we’ve improved performance greatly, adding support for newer units, and general efficiency improvements. I’ve also added extra behaviours to prevent massive factory spamming.

Numerous API changes are included as well! A handful of additions, such as unit resource usage are added, and a major change to the existing structure with the addition of a map object, and the movement of numerous API calls to the new object.

Various bugs in 0.25 have also been fixed, and more safe guards are now in place. I have also added extra optimisations, and rebuilt Shard in release mode, meaning a massive performance boost when idle.

You can find the full API listing in the ai/preload/api.lua folder, and I have added a Shard page to my projects section which I will be filling over the next 2 months.

Download here

• Fixed a bug causing the spring API call for UnitDamaged to be sent to Shard as a UnitIdle call. UnitDamaged calls should now work correctly, and phantom UnitIdle calls should no longer exist.
• UnitDamaged calls were never passed along from the AI object to all units and behaviour objects
• Removed numerous debug messages
• AttackHandler now maintains attack group sizes above a minimum value to prevent attack group sizes degrading to that of a single unit or two
• Minor fixes to task queue management and certain failure cases that were never accounted for

Optimizations:

• Checks added to prevent processing after the game has finished
• Attack targeting now only checks for targets every 6 frames not every single frame
• LUA_PATH is now set up correctly. Instead of calling game:ExecuteFile(file) or ai:ExecuteGameFile(file), you can now use the standard Lua library functions/keywords:
  • require – note if this fails the AI will exit and take the engine with it after printing a stacktrace to infolog.txt
  • include

Features:

• Added game:IsPaused()
• UnitDamaged now has a second parameter indicating the attacker. If the attacker isn’t available, nil will be passed and must be checked for
• Added game:MinimumWindSpeed()
• Added game:MaximumWindSpeed()
• Added game:TidalStrength()
• Added unit:IsCloaked()
• Added game:GetResource(idx)
• Added game:GetResourceCount()
• Added game: GetResource(name)
• Added Resource object
  
Resource {
name,
income,
usage,
capacity, -- how much we can store (-1 for unlimited)
reserves, -- how much is stored
gameframe, -- the game frame these stats were recorded at
},
• Added a new api.lua with a proxy object implementing game
• Added a preload folder, and moved api.lua, class.lua, and aibase.lua into it
• game:GetEnemies() now returns the enemy units in a normal lua table
• game:GetFriendlies() now returns friendly units in a normal lua table
• game:GetMapFeatures() now returns features in a normal lua table

Functionally, the game play should be near identical to 0.21, with only tiny improvements, however, performance should increase slightly, as well as stability. I’ve also added a lot of things that were requested by content developers using Shard, which allows them to do even more things!

Download it here