WhatsNew for Hexkit 4.3.3

This file contains the version history for the Hexkit Strategy Game System. Please refer to the separate ReadMe file for general information.

Version 4.3.3 (released 2015-09-30)

Recompiled & tested with Visual Studio 2015 and .NET Framework 4.6. The minimum requirement is still .NET 4 Client Profile, and the solution & project files are still in VS2010 format which is directly compatible with VS2015.

• Fixed corrupt data in saved games & scenarios due to redundant non-generic ICollection casts. Thanks to Lenny Woods for reporting this error!
• View: Display Theme: Added themes Aero 2 & Aero Lite, introduced with Windows 8.
• app.config: Added .NET 4.6 switch for better WPF control border scaling.
• Updated to Tektosyne 5.6.6 which was likewise updated for .NET 4.6 & VS2015.
• ReadMe: Updated requirements & links to Sandcastle Help Compiler & HTML Help Workshop.
• Class Reference: Changed format from Microsoft HTML Help to loose HTML pages.

Version 4.3.2 (released 2012-09-10)

• Updated to Tektosyne 5.6.5. No functional changes.
• Graphics.MapViewRenderer: Changed random frame selection from MersenneTwister.Default to private instance. MersenneTwister.Default is reserved for the gameplay thread.

Version 4.3.1 (released 2012-04-18)

• Updated to Tektosyne 5.6.2. No functional changes.
• Updated Class Reference to Sandcastle Help File Builder 1.9.4.0.
• Global.FilePaths: Elevated all files & folders to public visibility for documentation purposes.
• Fixed various references in XML comments.

Version 4.3.0 (released 2012-04-02)

• Updated to Tektosyne 5.6.1. No functional changes.
• Simplified internal processing of unhandled exceptions.

Version 4.2.10 (released 2011-07-10)

• Updated to Tektosyne 5.5.3. No functional changes.
• Updated Class Reference to Sandcastle Help File Builder 1.9.3.0.
• Changed all URL domains from kynosarges.de to kynosarges.org. The XML Schema target namespaces continue to use kynosarges.de for backward compatibility.

Version 4.2.9 (released 2011-05-31)

• Updated to Tektosyne 5.5.1. No functional changes.
• Updated Hexkit User’s Guide to remove discussion of graph algorithms, which is now found in the new Tektosyne User’s Guide.

Version 4.2.8 (released 2011-04-20)

• Updated to Tektosyne 5.5.0, now split in two assemblies. No functional changes.
• Updated Hexkit User’s Guide for the new graph interface and line-of-sight algorithm.

Version 4.2.7 (released 2010-10-24)

Updated Hexkit User’s Guide to switch diagram creation from Sparx Enterprise Architect to my new Class Diagrammer application.

• The diagram contents are unchanged, except for a few error corrections and layout adjustments.
• Added section 1.4, “The End of Hexkit”, which details why Hexkit development has ceased.
• Source Package: Added Class Diagrammer project file Hexkit.Diagrams.xml that was used to create the new UML diagrams. You must recompile the source package before running this project.
• Also updated Tektosyne to version 5.1.5, but this release contains no changes that affect Hexkit.

Version 4.2.6 (released 2010-07-08)

Updated to recompile Class Reference with new Sandcastle release.

• Also updated Tektosyne to version 5.1.1, but this release contains no changes that affect Hexkit.
• Removed superfluous CanExecute handlers from all GUI commands. This slightly reduces the size of the distribution packages, but once again causes no observable changes.

Version 4.2.5 (released 2010-06-14)

Updated to reflect changes in Tektosyne 5.1.0.

• Breaking Change: All members of Tektosyne.Graph types now receive or return Double instead of Int32 values when referring to distances or path costs. You will need to update any rule scripts that use the affected members.
• Despite this type change, Hexkit and its map grid still use integral values with unchanged semantics. PolygonGrid provides a new GetStepDistance method that returns an Int32 value like the previous GetDistance method; in other cases, simply cast any Double values to Int32. There are no conversion issues since any 32-bit integer fits precisely in a 53-bit mantissa.
• Updated Hexkit User’s Guide to reflect the changed Tektosyne.Graph types.

Version 4.2.4 (released 2010-05-09)

Updated to reflect changes in Tektosyne 5.0.2.

• Breaking Change: Some members of Tektosyne.Graph types were renamed or removed. In particular, all occurrences of the term “Location” were changed to “Node”. You will need to update any rule scripts that refer to the affected members.
• All Tektosyne.Graph types were changed to generically typed nodes, but this should not affect rule scripts since Hexkit’s map grid uses the same PointI nodes as before.
• Updated Hexkit User’s Guide to reflect the changed Tektosyne.Graph types.

Version 4.2.3 (released 2010-04-30)

Upgraded solution to Microsoft .NET Framework 4.0 Client Profile and Microsoft Visual Studio 2010, and to reflect changes in Tektosyne 5.0.0.

• Breaking Change:
  • Replaced geometric primitives (Point, Size, Rect) with new Tektosyne.Geometry structures. Accordingly, compiled rule scripts no longer reference the BCL assembly System.Drawing.dll.
  • Unless you were using other System.Drawing types in your rule script, the only visible change is that the new Tektosyne.Geometry structures are immutable, so you need to create new instances instead of changing existing ones.
• Removed assembly-level declarative security attributes, as .NET 4.0 has obsoleted this CAS feature.
• Fixed many parameter tags in XML comments, as the C# 4 compiler checks them much more thoroughly.
• Updated Hexkit User’s Guide to reflect the new Tektosyne types and namespace layout.

Version 4.2.2 (released 2010-04-12)

Updated to reflect changes in Tektosyne 4.5.0.

• There are no visible changes but pathfinding performance should be improved.
• Class Reference: Suppressed documentation of internal types & members, as there were too many of them lately.

Version 4.2.1 (released 2009-12-12)

Updated to reflect changes in Tektosyne 4.2.0.

• Changed type of map grid elements from Polygon to RegularPolygon.
• Removed class Hexkit.World.Twister – please use Tektosyne.MersenneTwister.Default instead.

Version 4.2.0 (released 2009-09-27)

Allowed changing initial variable values.

• Initial variable values used to be constant, either as defined by the scenario or as given upon variable creation. This was problematic for entity attributes and resetting faction resources since they are automatically reset to their initial values before modifiers are applied. Therefore, the rule script could not permanently change those values except by defining permanent modifiers, which might be undesirable.
• Added HCL instruction SetEntityVariableInitial that changes the initial value of an entity variable. For attributes, the current value is also reset to the new initial value. The corresponding Command method automatically reapplies any relevant attribute modifiers to the new current value.
• Added HCL instruction SetFactionVariableInitial that changes the initial value of a faction variable. The current value remains unchanged since resetting resources are always recalculated at the start of a turn.
• Setter methods for all standard attributes (Unit.AttackRange & Movement, Terrain.Difficulty & Elevation) now issue SetEntityVariableInitial instructions. These methods were in fact completely broken in older Hexkit versions since the next automatic modifier application would wipe out any values you had set! Example: the attack range of longbowmen in the Crécy scenario was set to one as they ran out of ammunition, but would suddenly return to five as they moved across the map…

Hexkit Game & Editor:

• Fixed application shutting down after options load failure which should allow the user to continue. WPF apparently terminates an application if any WPF display is attempted in the application constructor. Since this is where I had recently moved the options initialization code, I had to delay any related message display until application construction was complete.
• Depletion Indicators (Map View & Data View): Increased precision from 13 to 33 width steps, and from 5 to 31 color steps. Color steps are now computed on a linear ramp so precision can easily be increased further if desired.
• Map View: Reduced height of resource gauges, and border thickness of unit flags & resource gauges.
• View: Show Variables: Added Counter category. This was originally absent because counters are not supposed to be visible in Hexkit Game, but the ability to show entity counters greatly simplifies scenario editing and debugging.
• Overlay Images: Fixed drifting image position when changing the zoom level.
  • The the upper-left position of the overlay image is scaled with the zoom level, but the border around the game map is not. Since we ignored the map border during image positioning, this caused the overlay image to “drift” from its intended position as the zoom level changed.
  • Breaking Change: The (unscaled) upper-left map border is now always added to the (scaled) upper-left position of the overlay image. Please reposition your overlay images accordingly.
  • Hexkit Editor: Change Overlay Image: Left & Top now default to zero, rather than to the width & height of the map border.
• Changed all floating-point values in scenario & options XML files from “xsd:decimal” to “xsd:double”.
  • Non-breaking change since “xsd:double” is a superset of “xsd:decimal” for all practical purposes.
  • Fixed options load failure when opacity values of overlay images are stored in exponential notation, which is supported by “xsd:double” but not by “xsd:decimal”.

Hexkit Editor:

• Change Entity Instance: Fixed Show Images being initialized to the visibility flag of the underlying entity class, rather than of the entity instance being edited.
• Areas page: Change Site Contents: Terrain page:
  • Added asterisk (*) to indicate whether the default background terrain has been customized.
  • Fixed inability to define custom background terrain with the same class & name as the default background terrain, but with e.g. different variable values. This bug was due to outdated comparison code in World.WorldState.CreateArea, and would also affect the creation of Areas section files using the Debug: Save Map Contents command in Hexkit Game.

DeBray Bailey Images:

• Added image collections “image-item-tree-*” and “image-item-forest-*” which are identical with the corresponding images with a grass background (“image-terrain-grass-*”) but replace that background with transparency. The physical tiles were added to the PNG file “db terrain variants.png”.
• Added image “image-item-hole” which is identical with “image-terrain-grass-hole-1” but likewise replaces the grass background with transparency, and resides in the PNG file “db terrain variants.png”.
• Added black outlines to all road images for hexagon maps (“image-road-hexagon-*”) to improve their visibility on brown terrain.

Crécy Scenario:

• Renamed attributes “Mêlée” & “Archery” to “Attack” & “Attack (Ranged)”, respectively, for symmetry with the new “Defense (Ranged)” attribute.
• Added attribute “Defense (Ranged)” which explicitly specifies every unit’s defense against ranged attacks. Previous versions used the regular “Defense” attribute, and implicitly lowered the ranged defense for mounted units.
• Knights now define a ranged defense of 4 (dismounted) or 2 (mounted). This is somewhat lower than the implicitly assumed values of 5 and 2.5 in previous versions since dismounted knights proved too resilient in the Poitiers scenario.
• Added defense bonuses in both close & ranged combat to forests and wagon parks, and against ranged attacks only to towns and the windmill. This has little effect in the Crécy scenario but becomes important in the new Poitiers scenario.
• Added hypothetical scenario variant where all Genoese crossbowmen are protected by pavises, represented by a ranged defense of 8 instead of the implicitly assumed 3. This allows them to more effectively wear down the English longbowmen prior to the French cavalry charge.
• Adjusted the color of sloping ground at medium height, so as to improve the visibility of roads on such terrain.
• Changed the definition of the English faction’s initial restricted movement region from flood fill to terrain counter values. The equivalent area in the Poitiers scenario is too irregular to use the old flood fill trick, and explicit marking also greatly reduced the region’s size.
• Changed the definition of the French faction’s initially mobile units (the Genoese crossbowmen) to unit counter values. Again, this is because simply picking one unit type wouldn’t work for the Poitiers scenario.

Poitiers Scenario:

• Added new scenario based on the battle of Poitiers (or Maupertuis), sharing the rule script and many of the units of the Crécy scenario. The Crécy scenario guide was enhanced to cover both scenarios, and the Hexkit User’s Guide describes each variant’s combination of subsections.
• Added hypothetical scenario variant where the second French division, led by the three younger Valois, attacks normally instead of fleeing the battle prematurely. With some luck, this allows the numerically superior French army to win by attrition.

Version 4.1.6 (released 2009-07-16)

Added unit resource gauges, a.k.a. health bars.

• Map views optionally show resource gauges for all units, indicating the depletion state of any desired unit resource. The default settings show the standard strength resource, but only for damaged units.
• Hexkit Game & Editor: View menu: Added Show Gauges dialog that lets you select a unit resource whose depletion state to show, as well as various display settings.
• Hexkit.Options.xsd: Added optional XML attributes “gaugeResource” of type xsd:string and “gaugeResourceFlags”, based on new enumeration “gaugeDisplay”, to XML element “mapView”.
• Options.MapViewOptions: Added string property GaugeResource and property GaugeResourceFlags of new type Options.GaugeDisplay.
• Many other changes to implement the new display options.

Devirtualized standard variable accessors.

• Standard variables were introduced so that scenario authors would not require rule script overrides when different entity classes used different scenario variables for the same gameplay purpose. The accessors for standard variables remained virtual to allow further customization. However, this was not really necessary, and so we devirtualize all accessors for greater simplicity and better performance.
• Breaking Change: Rule scripts that override any of the listed properties or methods must be rewritten.
• Battle of Crécy: Removed CustomUnit.AttackRange override. The AttackRange attribute is now directly changed by method SetAmmunition.
• World.Terrain:
  • Added convenience methods SetDifficulty & SetElevation.
  • Devirtualized properties Difficulty & Elevation.
• World.Unit:
  • Added convenience methods SetAttackRange & SetMovement.
  • Devirtualized properties AttackRange, Movement, Morale & Strength, and methods SetMorale & SetStrength.

Added global objects for all standard variables.

• Each standard variable now has a corresponding global object of type AttributeClass or ResourceClass. These are “pseudo-variables” which do not appear in the corresponding VariableSection collection. All they do is provide “magic” identifiers and appropriate display names so that GUI code can conveniently mix standard variables and concrete variables in the same context.
• Breaking Change: The “magic” identifier for all standard variables combines the prefix “standard-” with the variable’s name. This is technically a breaking change since someone might have used such an identifier for a concrete variable. However, real variable identifiers should always start with a category prefix (“attribute-”, “counter-”, or “resource-”) so a collision is unlikely.
• Scenario.AttributeClass: Added read-only static fields StandardAttackRange, StandardDifficulty, StandardElevation & StandardMovement.
• Scenario.ResourceClass: Added read-only static fields StandardMorale & StandardStrength.

Version 4.1.5 (released 2009-06-27)

• Fixed arithmetic overflow crashes (see WhatsNew file for Tektosyne 4.1.7).
• Hexkit Game:
  • Data View: Removed excessive spacing around Site Owner & Unit Owner display.
  • Fixed crash when changing the zoom level during command replay while a temporary visual effect is being shown. Changing the zoom level automatically removes such effects; the crash occurred when the graphics engine attempted to remove the effect again.
• Battle of Crécy: Changed visual representation of sloping terrain to color grades, using a variety of terrain images with shifted color channels.

Version 4.1.4 (released 2009-06-25)

Added option to change the application display theme.

• WPF provides several so-called “themes” that determine the look of standard GUI elements. An appropriate default theme is selected automatically, but Tektosyne provides a hack to select arbitrary themes. This hack is now exposed in Hexkit for your amusement.
• Hexkit Game & Editor: View menu: Added Display Theme submenu with entries for all available WPF themes.
• Hexkit.Options.xsd: Added XML attribute “theme” to element “view”, based on new enumeration “defaultTheme”.
• Options.ViewOptions: Added property Theme of type Tektosyne.Windows.DefaultTheme.

Hexkit Editor:

• Master page: Saving the Master section now correctly marks all inlined subsections as unchanged.
• Change Entity: Images page: Available Images window is now a child window of the dialog and thus appears always on top. The original idea was to let users switch freely between both windows, but having the Available Images window constantly disappear behind an enlarged dialog or application window was just too annoying.

Version 4.1.3 (released 2009-06-21)

Added optional color channel shifting for image stack entries.

• You can now apply positive or negative shifts to an image’s sRGB color channels when defining the image stack of an entity class.
• Hexkit Editor: Change Entity: Images page: Added numeric controls to shift the sRGB color channels of the selected image stack entry.
• Hexkit.Scenario.xsd:
  • Added simple XML type “byteOffset” and complex XML type “colorVector”.
  • Added optional nested XML element “colorShift” to complex type “imageStack”.
• Scenario.ImageStackEntry: Added property ColorShift of type Tektosyne.Windows.ColorVector.

Hexkit Editor:

• Images page: Fixed Image list items disappearing when changed. (WPF apparently requires Items.Refresh calls whenever user-drawn list items change.)
• Change Entity Class: Images page: Available Images list now appears in a separate resizable window.
• Change Overlay Image: Added tool tip to the File text box showing the full path to the current image file.

Revised storage of image stack entries.

• The image stack entries of an entity class were originally conceived as pairs of EntityImage identifiers and very few display parameters, stored as structures and serialized by EntityClass rather than ImageStackEntry. As it happens, those parameters grew and multiplied until they were decidedly too fat for a structure…
• Along the way I also decided to give the XML element a unique name, and remove a rather pointless storage optimization (multiple image IDs per element) that got in the way of the standard XML serialization mechanism for Hexit.Scenario types.
• Hexkit.Scenario.xsd:
  • Breaking Change: Renamed nested XML element “images” of element “entityClass” to “imageStack”, and changed IDREFS attribute “ids” to IDREF attribute “id”.
  • Hexkit Editor can still read the old storage format. Load your custom Entity section files into Hexkit Editor and save them back to automatically convert to the new storage format.
• Scenario.EntityClass.ImageStack: Changed from identifier/ImageStackEntry dictionary to plain ImageStackEntry list.
• Scenario.ImageStackEntry:
  • Changed from structure to sealed class that derives from ScenarioElement and implements ICloneable. Like most other scenario types, ImageStackEntry can now (de)serialize itself.
  • Image: Changed from direct EntityImage reference to identifier/reference pair for an EntityImage.

Version 4.1.2 (released 2009-06-10)

Added option to show static overlay images on map views.

• Hexkit now supports two variants of static overlay images that can be stretched or compressed to cover the entire map grid.
• The first variant appears both during editing and during gameplay, and is saved to a scenario’s Areas section. This image is shown below the map grid and is intended to replace some or all background terrains (and possibly foreground terrains as well). For this purpose, Entity classes and instances can be made transparent with a new visibility option (see below).
• The second variant appears exclusively during editing, and is saved to the Hexkit Editor options file. This image is shown with a variable opacity above the map grid, and is intended solely as an editing aid when creating map grids from hand-drawn maps.
• Known Issue: Loading and displaying large overlay images may take several seconds, even on fast systems. There’s nothing I can do about this, except to hope that the WPF performance improvements in .NET 4.0 will address this issue as well.

Added option to show entity images on map views.

• This option is enabled for all entity classes by default, and can be disabled for entity classes or individual instances.
• When disabled, the Hexkit graphics engine simply skips the entity while drawing a map view, effectively rendering that entity fully transparent. Use this setting for background terrains to let an overlay image show through.
• Note: You must still define a valid image stack for all entity classes. That image stack governs site connections, if any, and will be shown in any other GUI controls, such as image lists and dialogs.

Hexkit Editor:

• Image file dialogs now accept any supported image file format (BMP, GIF, JPEG, PNG, TIFF), not just PNG. Images with an unsupported color format (such as GIF) are automatically converted to 32-bit RGBA format.
• Added dialog Change Overlay Image that allows you to select an overlay image (in any supported format) and change its size and position.
• Areas page:
  • Added buttons Overlay and Editor Overlay to define the two variations of overlay images.
  • Added opacity slider that appears on the map view when an Editor Overlay has been defined. This slider allows you to change the opacity of that image so you can simultaneously see the overlay image and the map grid beneath it.
• Change Entity Class & Change Entity Instance: Added Show Images options that determine whether an entity’s image stack is drawn on map views.
• Change Image: Frame coordinates are no longer restricted by the maximum value for map coordinates (10,000) but only by the maximum Int32 value (2,147,483,647).

Internal Changes:

• Hexkit.Options.xsd & Hexkit.Scenario.xsd: Added XML elements and attributes for the new features. All additions are optional and do not break existing options or scenario files.
• Options:
  • Added class EditorOptions that holds user settings specific to Hexkit Editor.
  • EditorOptions: Added property Overlay of type Scenario.OverlayImage, representing the overlay image that appears during editing only.
• Scenario:
  • Added class OverlayImage that holds file path and bounds for either overlay image variant.
  • AreaSection: Added property Overlay of type OverlayImage, representing the overlay image that appears during both gameplay and editing.
  • EntityClass & EntityTemplate: Added boolean property IsVisible that defaults to true and null, respectively.
• World.Entity.IsVisible:
  • Changed setter from internal to private visibility.
  • Changed semantics to combine the IsVisible flags of the underlying EntityClass and EntityTemplate, if any.
  • Gameplay code should never examine this flag, it’s purely for visual appearance. In future Hexkit versions that support “fog of war”, entity visibility will be governed by a new mechanism.

Version 4.1.1 (released 2009-05-25)

Hexkit Game:

• Data View: Fixed Site Contents list jittering back and forth between entries under certain conditions, e.g. at the start of the Roman Empire scenario.

Hexkit Editor:

• Areas page: Fixed map view not being redrawn immediately after changing site selection in Replace mode.

Internal Changes:

• Class Reference: Updated to Sandcastle Help File Builder version 1.8.0.1 which fixed the missing this qualifier for extension methods.
• World.WorldState.Sites: Changed from Site[,] to read-only two-dimensional ArrayEx<Site>. This closes the last major loophole for unintentional changes to the world state.

Version 4.1.0 (released 2009-05-17)

Renamed Item & Special Categories

• Renamed Item to Upgrade to reflect the newly changed item semantics. Physical items that may appear on the map are now exclusively represented by terrain entities, whereas upgrades always represent some kind of faction bonus such as technical advances.
• Renamed Special to Effect, which is a proper noun and reflects the fact that effect entities may represent not just transient “special effects” (blood splatters, explosions etc.) but also more permanent local effects such as fog. Unfortunately, this name clashes with the WPF Effect class, but WPF hogs so many generic terms that this is almost unavoidable.

Changed Item/Upgrade Semantics

• Previously, items could be placed on the map or kept in a faction inventory. Their variable modifier and resource transfer effects were implied by their status, and could be overriden by a rule script.
• Now, upgrades are always owned by faction and never placed on the map. They exclusively represent faction bonuses, technological advances, or similar intangibles.
  • Removed the distinction between “regular” items and faction items. All upgrades are faction items, so to speak.
  • Removed the Recover ability of units & items and the entire item recovery mechanism. This also simplified the Seeker AI algorithm.
  • Upgrades do not appear on their owning faction’s home site when the faction is defeated.
• Variable modifier effects are determined explicitly by the new modifier target system, as with other entities.
• Automatic resource transfer is determined explicitly by the new resource transfer mode, as with other entities.
• The Drop Shadow option defaults to false for upgrades, since drop shadows are only drawn on the map view anyway.

Changed Variable Modifier System

• Previously, entities could define a single modifier for any attribute or resource variable. The target for this modifier (the entity itself, its owner, or certain units) was determined implicitly by heuristics that could be overriden by a rule script.
• Now, entities can define multiple modifiers per variable, each affecting one explicitly specified Modifier Target. However, the modifier system (along with a new dedicated caching mechanism) is now so complex that rule script overrides are no longer possible.
• Possible targets include Self (the entity’s own variables), Owner (the owner faction’s resources), and a variety of Unit targets.
• Modifiers of unplaced entities are completely ignored, except for upgrades. That means unplaced units no longer incur support costs.
• Modifiers may target either local or ranged units, and units of either the same or different owner than the defining entity.
  • “Local” indicates the entity’s current map site for placed entities, or the owner faction’s home site for upgrades.
  • Ranged modifiers apply within a Modifier Range defined by each entity class. The range may be zero to indicate that ranged modifiers affect all placed units, or a positive value to indicate a range of map sites around the “local” site.
  • The ranged modifiers of an upgrade entity are ignored if the entity defines a non-zero modifier range and the faction does not define a home site, or does not currently own its home site. The modifiers are always applied if the entity defines an unlimited modifier range.
• Faction resource modifiers are not associated with targets, and now only apply to faction resources. Use owned entities for all other targets.

Changed Resource Transfer System

• Previously, resource transfer from items, terrains, or effects to local units or owning factions was determined implicitly by heuristics that could be overriden by a rule script.
• Now, resource transfer is controlled explicitly by a new Resource Transfer Mode defined by each entity class.
• When disabled, an entity never automatically transfers resources to anyone else.
• When enabled, upgrades automatically transfer resources to their owner, and terrains & effects automatically transfer resources to any local units.
• The resource transfer mode also determines whether fully depleted entities are retained or automatically deleted.
• Since automatic resource transfer is linked to the new variable modifier system by way of the supply system, both the resource transfer system and the supply system are no longer customizable by rule script overrides.

Hexkit Game & Editor:

• Changed any affected controls & labels to mirror the above changes to the Hexkit data structures.
• All list view columns with centered or right-aligned content are now properly resizable, thanks to Ian Griffiths’ workaround for WPF ignoring column alignment settings.
• Hexkit Game: Info: Placement Sites: Fixed swapped contents of Site & Owner columns.

Demo Scenarios:

• Troll Chess:
  • Changed the four bonus items to terrain entities that can be captured by any general or heavy unit.
  • Changed the Trolls’ health bonus from a faction modifier to an upgrade entity (Troll Blood).
• Battle of Crécy: Changed the ranged morale modifiers provided by English knights and French leaders to the new modifier target system.

Hexkit.Scenario.xsd:

• Breaking Changes: You must manually update your scenario XML files with a text editor to mirror the following changes. Sorry, but the Hexkit Editor infrastructure cannot handle renamed XML elements!
  • Renamed nested XML elements “item” and “special” of complex type “entities” to “upgrade” and “effect”, respectively.
  • Renamed nested XML elements “item” and “buildableItems” of complex type “factionClass” to “upgrade” and “buildableUpgrades”, respectively.
  • Renamed nested XML element “special” of complex type “area” to “effect”.
• Removed complex type “itemClass”. Upgrade classes are represented directly by “entityClass”, just like effect classes.
• Changes to complex type “entityClass”:
  • Added integer XML attribute “modifierRange” (default zero). The attribute is only used with the new ranged modifier targets, so there are no compatibility issues.
  • Added XML attribute “resourceTransfer” of new enumeration type “resourceTransferMode”. The attribute defaults to “None”, so existing Entity section files can be read but exhibit changed semantics.
  • Changed nested XML elements “attributeModifier” & “resourceModifier” from type “variable” to new derived type “variableModifier”, adding attribute “target” of new enumeration type “modifierTarget”. The attribute defaults to “Self”, so existing Entity section files can be read but exhibit changed semantics.
  • Breaking Change: Removed boolean XML attribute “recover”, as the corresponding item recovery mechanism no longer exists. Hexkit Editor will ignore these attributes when reading existing Entity section files.
  • Breaking Change: Changed nested XML element “valuation” to a floating-point attribute. I’m not sure why I ever used an element here, as this single number should clearly have been an attribute all along. Hexkit Editor still reads valuations as nested elements in this version, so you can read existing Entity section files and save them back to change all valuations to attributes.
• Breaking Change: Removed nested XML element “item” from complex type “area”, as upgrades cannot be placed on the map. There is no automatic conversion for this change. Hexkit Editor will ignore these elements when reading existing Area section files, but this is very likely not what you want. You will have to manually edit your use of items in existing scenarios, changing them into either terrains or upgrades.

Hexkit.Session.xsd:

• Breaking Change: Added required XML attribute “target” of new enumeration type “modifierTarget” to element “SetEntityVariableModifier”. There’s no point in making this change non-breaking since modifier semantics are different in this version anyway.

Other Internal Changes:

• Publish.proj: Changed archiver for source package from Info-ZIP to 7-Zip.
• World.Entity:
  • Added boolean property IsModifiable that indicates whether the entity’s variables are subject to automatic modifications. Succeeds for placed & owned units, placed terrains & effects, and owned upgrades.
  • GetOwnerEntities & GetSiteEntities: Removed both methods and their overrides since they merely duplicated Faction/Site.GetWritableEntities and incorrectly exposed writable collections to rule script code.
  • ValidateOwner & ValidateSite: Changed visibility of both methods and their overrides from protected to internal since rule script code should never call them.
• World.Faction:
  • Delete: Now correctly deletes any unplaced terrains owned by the faction.
  • GetWritableEntities: Changed visibility from public to internal… oops!
  • Initialize: Moved initial global update of all entity attributes to World.Commands.BeginTurnCommand.GenerateProgram since this action cannot be skipped or customized. The default implementation of Initialize is now empty, as it should be.
• World.Site: Added internal method GetWritableEntities that returns the writable site stack for the specified EntityCategory.
• World.Site.(Set)TerrainChanged & World.WorldState.TerrainChanged: Changed visibility from public to internal since rule script code should not interact with the terrain caching mechanism.
• Many other changes to implement the new names and mechanisms described above.

Version 4.0.5 (released 2009-03-07)

Hexkit Game:

• Map View: Fixed target sites occasionally not getting scrolled into view when replaying commands. This bug was rather confusing since the code was correct and unchanged from the old Windows Forms version. Turns out WPF unilaterally decides to “optimize” drawing performance by simply ignoring small changes to the scroll position! An explicit UpdateLayout call seems to prevent this behavior.
• Event View: Removed unintentional empty line between event summary and entity list when there are no event details.
• Status Message: Computer player field is now correctly cleared whenever the session state changes.

Hexkit Editor:

• Added thousands separators to numeric inputs where appropriate.

Increased maximum range for variable values from ±10,000,000 to ±100,000,000.

• The new maximum value equals the square of the maximum number of sites in each map dimension (10,000) and thus ensures that any map location can be encoded in a single variable value, such as “counter-location” in the new version of the Roman Empire scenario.
• Hexkit.Scenario.xsd: Changed simple type “variableRange” from ±10,000,000 to ±100,000,000.
• Scenario.VariableClass.AbsoluteMaximum/Minimum: Changed to +100,000,000 and –100,000,000, respectively.
• World.Variable: Added static methods FromLocation & ToLocation to decode & encode map coordinates stored in a Variable value.

Roman Empire Scenario:

• Added mounted units with higher land movement (which is halved at sea). Persia’s Royal Guard is now mounted; Carthage and Celts get the new Heavy Cavalry; Carthage and Persia get the new Light Cavalry; and the existing Skirmisher infantry is now available to everyone.
• Added Merchant unit that is automatically created in each civilized capital. Merchants travel randomly between a faction’s cities, paying taxes upon arrival at their destination. Enemy factions can capture travelling merchants and loot their trade goods.
• Adjusted gold income from cities & capitals to compensate for new merchant system.
• Celts, Egypt & Persia start out with a few more settlements as they were somewhat underpowered.
• Known Issue: The Seeker algorithm has recently acquired a habit of removing armies from sieges for no apparent reason. I suspect that this is a result of some tweaks I made for the Crécy scenario which didn’t carry over too well to the Roman Empire scenario. A real fix will probably require a new AI algorithm with better target acquisition and unit cooperation…

Version 4.0.4 (released 2009-02-13)

Hexkit Game:

• Fixed some list views not automatically scrolling selected items into view, notably the data view’s Entity List.
• Info: Faction Ranking:
  • This dialog now appears automatically at the end of a game, opened on the Graphs page.
  • All list items that correspond to factions now show the corresponding faction color.
  • Tables page: Faction list correctly shows items with equal rank in activation order.

Hexkit Editor:

• Fixed some list views not automatically scrolling selected items into view.
• Entities: Change Placement Sites: Fixed nonfunctional Allow Default Sites option.

Breaking Changes for Scenario Authors: Standardized names of boolean properties and XML attributes.

• Hexkit.Scenario.xsd: Dropped “has” & “is” prefix, respectively, of boolean attributes “hasDropShadow” & “isTranslucent” of complex type “entityClass”. The corresponding C# properties remain unchanged.
• Scenario.EntityClass.DefaultPlace & Scenario.EntityTemplate.RandomFrame: Added “Use” prefixes. The corresponding XML attributes remain unchanged.
• World.Entity.Visible & World.Faction.Resigned: Added “Is” prefixes.

Internal Changes:

• Changed AssemblyVersion back to AssemblyFileVersion since WPF cannot handle auto-incremented build numbers. XAML requires two compilation passes between which an auto-incremented build number may increase, resulting in version mismatches and .NET load errors for signed assemblies.

Version 4.0.3 (released 2009-02-08)

Moved all command execution (immediate & replayed) to background threads, eliminating reentrant DoEvents calls.

• Map view animations are now smoother (at least on multicore systems…).
• Fixed application hanging when resizing the main window during command replays.
• Pressing Escape immediately ends the pause between queued human player commands.

Hexkit Game:

• Property List & Build Entities: Color bars that highlight specific numbers now end in transparency rather than in the standard window color. This looks better and also fixes invisible selected numbers under the Windows XP desktop scheme.
• Data View: Clicking the Site Owner & Unit Owner links automatically completes an ongoing command execution or replay, just like the corresponding Info: Faction Status menu item.
• Info menu: About Scenario, Entity Classes & Variables no longer automatically complete an ongoing command execution or replay, as they are not affected by the current world state. This behavior is consistent with double-clicking on Entity & Property list items in the data view.
• Breaking Change: Older Hexkit Game session files are not compatible with this version due to revised image instructions (see below). To load older save games, temporarily substitute the previous Hexkit.Session.xsd file.

Internal Changes:

• World.Instructions.ImageInstruction: Removed boolean property Remain. This flag was an obsolete hack required by the old Windows Forms animation engine to prevent flickering at the end of a movement path.
• Hexkit.Scenario.xsd: Removed boolean attribute “remain” from complex type “imageInstruction”.

Version 4.0.2 (released 2009-01-17)

Removed difficulty settings for computer players – they never had any effect and just complicated things.

• Game menu: Removed Default submenu with difficulty level options. The Game menu is now disabled when no game is active.
• Change Players: Computer players appear by index rather than difficulty level. Multiple factions may be assigned to the same computer player, as with human players. Computer player options are always editable.
• Breaking Change: Older Hexkit Game options & session files are not compatible with this version because difficulty levels were removed. To load older save games, unpack them and delete all “<options level="..." />” elements you can find.

Hexkit Game & Editor:

• Fixed application ignoring Alt shortcut keys for main menu items.
• Fixed crash when attempting to start a second instance of the same application. Did you know that the WPF method Application.Shutdown can actually return to the caller? Neither did I…

Hexkit Game:

• Known Issue (fixed in 4.0.3): Resizing the main window during replays may hang the application, apparently due to conflicts between reentrant WPF messages. Bring up Task Manager (Ctrl+Shift+Esc) to kill the process when that happens, or even better avoid resizing the window during replays. The next Hexkit version will feature a proper multithreaded replay engine that should fix this issue.
• Pressing Escape while queued human player commands are being executed now skips all delays between queued commands, in addition to all map view events.
• Property List: Added color bars to visualize the state of depletable entity resources.
• Map View:
  • Slightly accelerated redrawing by eliminating redundant Lock/Unlock calls.
  • Fixed map view not centering faction locations when opening saved games.
  • Fixed map view not scrolling target locations into view during replays.
• Game: Player Setup, Info: Faction Status & Faction Ranking: Fixed nonfunctional OK button and deactivated main window when dialog was hidden by a Faction Entities dialog.
• Info: Command History: Last command is now automatically selected and scrolled into view.
• Command: Build Entities:
  • Added color bars to highlight insufficient build resources.
  • Fixed missing display of current & buildable number of entities. I can’t believe I missed that one…

Hexkit Editor:

• Fixed application ignoring Alt shortcut keys for tab-specific controls.
• Changed or removed Alt shortcut keys for tab-specific controls that conflicted with main menu items.
• Change Variable: Added Deplete option to indicate depletable entity resources.

Internal Changes:

• Options: Removed classes HumanOptions & ComputerOptions, as well as reference from Hexkit.Players assembly.
• Scenario.ResourceClass: Added boolean property IsDepletable and renamed Limit & Reset to IsLimited & IsResetting, respectively.
• World.Variable: Added boolean property IsDepletableResource and renamed IsLimitResource & IsResetResource to IsLimitedResource & IsResettingResource, respectively.
• Hexkit.Options.xsd: Removed simple type “computerLevel” and elements “human” & “computer”.
• Hexkit.Session.xsd: Removed simple type “computerLevel” and attribute “level” of element “computer”.
• Hexkit.Scenario.xsd: Added boolean attribute “deplete” to nested element “modifier” of element “resourceClass”.

Version 4.0.1 (released 2009-01-11)

Revised command execution mechanism – it’s still based on DoEvents but guarded against reentrant calls.

• Fixed spurious errors during command replays.
• Allowed user input during map view events, both for human player commands and for history commands during interactive replay.
• All File menu options, Game: Player Setup, and Replay: Pause Replay, Skip Faction & Stop Replay instantly complete command execution.
• Replay: Stop Replay is now enabled during human player command execution, so you can skip map view events by pressing Escape.
• All Info & Debug menu options (except Debug: Show Bitmap Catalogs) now also complete command execution and stop interactive replay.

Hexkit Game:

• Status Bar: Computer message field now grows with main window, as in previous Hexkit versions.
• Command: Build Entities: Required build resources are now correctly formatted with thousands separator.
• File menu: Added hotkey Ctrl+F4 for Close menu option.

Hexkit Editor:

• Images: Change Image: Selecting another image file now correctly updates the frame list.
• Areas: Change Default Contents: Fixed crash due to missing null check. Thanks to Olaf Kleist for reporting this error!

Internal Changes:

• Added explicit CultureInfo.CurrentCulture argument to all String.Format and ToString calls that generate display output, except in rule scripts.
• Changed all named XAML elements to private visibility where possible, reducing the number of undesired entries in the Class Reference.

Version 4.0.0 (released 2008-12-24)

Upgraded Hexkit to .NET Framework 3.5 SP1 and Windows Presentation Foundation.

• Most dialogs now support intelligent resizing, with any present map views and/or list views growing to fill the additional space.
• Some windows and dialogs offer splitter bars for manual redistribution of the available width or height between resizable elements.
• Bitmap catalogs and all bitmap tiles, on map views and elsewhere, are now scaled to the current screen dpi and always have the same relative size compared to GUI text and controls.
• Architectural Note: Command replays and map view events rely heavily on reentrant calls and active wait using Tektosyne.WindowsUtility.DoEvents. This design is rather ugly and causes some annoying stutter during unit movement, but WPF does not provide any decent method for synchronous display updates. I’ll move command replay to a separate thread in a future release so that WPF has the main thread to itself.
• Known Issue (fixed in 4.0.1): Due to the active wait on reentrant DoEvents calls, attempting to skip the current faction during command replays may result in command execution errors. Fortunately, this does not appear to have any grave consequences.
• Known Issue: This is actually an old issue but I only noticed it with this release. Since .NET 3.5 you can run Hexkit from a shared network drive but the online help will only show blank pages. HTML Help relies on an ActiveX control for Internet Explorer, and that control cannot run over a network for security reasons. There is no workaround, other than running Hexkit from a local hard disk.

Hexkit Game & Editor:

• Fixed error message shown when writing options file fails.
• Map View:
  • Entities may have drop shadows to visually distinguish them from background terrain. This effect applies to units & items by default, although scenario designers can enable or disable drop shadows for arbitrary entities with the new Add Drop Shadow option (see below).
  • Attack & movement arrows now show a bright spot flowing in the direction of the arrow.
  • Selected site is now marked by a pulsating color band rather than a static white outline.
  • WPF animations put a heavy load on the CPU and may irritate some users, so you can disable these two features with the new Use Static Arrows/Marker options (see below).
• View menu:
  • Adjusted zoom levels. The new sequence is 40%, 60%, 80%, 100%, 125%, 160%, 200%.
  • Added Performance submenu with four options to speed up map view drawing and counteract the sluggishness of WPF.
    • Use Bitmap Grid draws map grids using fast but ugly bitmap copying rather than neat but slow WPF drawing commands.
    • Use Opaque Images assumes that the pixels of all entity images are either fully transparent or fully opaque, unless explicitly marked as translucent with the new IsTranslucent flag. Opaque images are drawn using fast pixel copying rather than slow alpha blending; however, this may cause ugly seams around the edges of scaled images.
    • Use Static Arrows draws attack & movement arrows with static red or blue colors, as in previous Hexkit version.
    • Use Static Marker draws the site selection marker as a static white outline, as in previous Hexkit version.

Hexkit Game & Scenarios:

• Site Contents List (main window): Added separator bars between entity categories.
• Property Lists (main window & dialogs): Added separator bars between property categories.
• Battle of Crécy: Changed sloping terrain from grassland with grain to sand with weeds. Very unrealistic but much more distinctive!
• Breaking Change: Moved class Global.Random to World.Twister, both for disambiguation with System.Random and to remove Hexkit.Global.dll from the list of libraries referenced by rule scripts.

Hexkit Editor:

• Images tab (Hexkit Editor main window & Change Entity dialog):
  • Images now display their identifier in a tool tip.
  • Images are now correctly sorted in natural rather than lexical order by identifier.
  • Known Issue: When switching to this tab for the first time or after changing data, the application freezes briefly while the list of images is being redrawn. This is a “feature” of WPF background rendering: we cannot show a wait cursor because the completion of rendering is not communicated to the caller. A future WPF version should offer a VirtualWrapPanel that eliminates the slowdown, however.
• Entities: Change Entity:
  • Renamed existing Other tab to Abilities tab, and added new Other tab with the following options.
  • Moved Computer Valuation setting from Abilities tab to Other tab.
  • Added Add Drop Shadow option that applies a drop shadow effect to the image stack. This option is enabled by default for units & items, disabled for terrains & special effects, and unavailable for background terrains.
  • Added Translucent Images option that will cause Hexkit to use alpha blending when rendering the image stack, even if the Use Opaque Images performance option is enabled.

Internal Changes:

• Global: Renamed several types for disambiguation with System types so we can import the Hexkit.Global namespace into Hexkit source files.
• Scenario.Image: Renamed back to EntityImage because I got sick of all the name collisions with standard classes…
• Hexkit.Options.xsd: Added boolean attributes “bitmapGrid”, “opaqueImages”, “staticArrows” & “staticMarker” (all default false) to complex type “view” (and not to “mapView” because these options affect all map views equally).
• Hexkit.Scenario.xsd: Added boolean attributes “hasDropShadow” and “isTranslucent” (default false) to complex type “entityClass”. The default for “hasDropShadow” is true for the derived types “unitClass” and “itemClass”, and false for “terrainClass” and “specialClass”.

Version 3.7.2 (released 2008-06-10)

Crécy Scenario: Demoralized units now get a chance to recover their morale if the total friendly strength is at least twice the total enemy strength, with a chance proportional to the strength difference. Thanks to Giftzwerg for this idea!

Hexkit Editor: The installer now grants all users write access to the Images and Scenario directories in the Hexkit installation folder. This means limited users can now finally edit scenario files in their default location.

Upgraded source code to Visual Studio 2008. The binaries still target .NET 2.0.

• Replaced NAnt.build with Publish.proj for MSBuild. This script only builds the distribution package; use MSBuild on Hexkit.sln to perform unsigned builds from the command line.
• Hexkit.Global.csproj: Removed SearchReplace.exe and corresponding pre-build event since VS2008 can generate resource properties with public access level.
• Hexkit.Editor.csproj & Hexkit.Game.csproj:
  • Replaced separate application manifest files with embedded “app.manifest” standard files.
  • Replaced Common Controls dependencies in manifest files with Application.EnableVisualStyles calls.

Version 3.7.1 (released 2008-06-02)

Thoroughly revised Hexkit User’s Guide to reflect the current version. Other noteworthy changes:

• Chapter “Hexkit Classes”: Broken into two chapters covering Hexkit.Scenario and Hexkit.World types, respectively.
• Chapter “Game Commands”: Added dedicated section on command automation.
• Chapter “Custom Rules”: Added full pseudocode programs for all customizable game mechanics. The descriptions of such mechanics in previous chapters were cut or shortened, and any relevant explanations moved to this chapter.
• Added dedicated chapter “Pathfinding” that covers this subject in much greater detail than before.
• Chapter “Computer Players”: Replaced or enhanced text descriptions with pseudocode programs as appropriate.

Crécy Scenario:

• Added property CustomUnit.MoraleModifier that returns the ResourceModifiers element for the MoraleResource, if any.
• Fixed premature restoration of morale modifier to French leaders when they are getting fresh horses.

Reverted latest complication of pathfinding mechanism.

• World.Unit: Removed virtual method CanTraverse. While updating the pathfinding documentation I discovered that this method did not serve any particular purpose. Its functionality is now part of CanMakeStep, as it should be. The change list for version 3.7.0 has been edited to reflect the new situation. We have always been at war with Eurasia.

Variable change event now reports new variable value.

• World.Entity & World.Faction: Added integer parameter value to virtual OnVariableChanged methods in both classes. This is the value that was originally supplied to the HCL instruction that changed the variable; the actual new value differs if the supplied value was outside the variable’s legal range.
• Crécy Scenario: Replaced SetMorale override with OnVariableChanged override so we no longer need to restore the morale modifier in the UpdateResources override. This is the recommended way to hook into the variable update mechanism, as described in the new Hexkit User’s Guide.

All Entities supplied to a Command must have the same Category.

• The Entity class defines virtual command methods that take a list of entities. Such methods are always invoked on the first entity in that list, and some are overriden in derived classes such as Unit. That is problematic if the list contains entities of different categories since Unit methods assume that all specified entities are units. So all entities are now guaranteed to be of the same category. This was already the case in practice, just not formally required.
• World.Commands.EntitiesCommand.Validate: Throws InvalidCommandException if any two Entities elements specify a different Category.

Internal Changes:

• Hexkit.Global.csproj: Added missing quotes around command name and first argument in prebuild event. This should finally allow Hexkit to compile in directories containing spaces, including folders under “My Documents”. Thanks to Pat O’Hara for solving this mystery!
• World.Faction.GetAvailableClasses & GetBuildableClasses & GetEntities: Changed return values for EntityCategory.Special from null references to empty collections. Special is invalid for faction possessions anyway, but this change avoids possible null reference exceptions.

Version 3.7.0 (released 2008-04-28)

• Reformatted WhatsNew file for clearer grouping of related changes.
• Upgraded binary package to Inno Setup 5.2.2. On Windows Vista, this installer version drops the user back to non-elevated credentials when (optionally) starting Hexkit Game after the installation is complete.
• DeBray Bailey Images: Added images for medieval mortar (“image-item-mortar”) and covered wagon (“image-item-wagon”).
• Troll Chess: Retired default version that does not use a custom rule script. Much of the functionality that used to require customization has been integrated into the Hexkit Game application by now.
• Troll Chess & Roman Empire: Renamed Movement attribute (= terrain movement cost) to Difficulty, and Speed attribute (= unit movement allowance) to Movement. Difficulty values are always positive whereas Movement values used to be negative in Troll Chess.

Breaking Changes: Older rule scripts will not compile in this release.

• Added Healing ability for unit classes. This ability defaults to false but must be set to true to recreate the computer player behavior of previous versions.
• IRulesFactory: Added method Initialize, see “Default Rules.cs” for the new default implementation.
• Unit: Moved all static methods to new class Finder, and changed names and default implementations of several virtual properties.
• Unit.CanMakeStep & CanOccupy: Added parameter originalSource and changed default implementations.
• Unit.CreateAttackEvent: Replaced integer parameters with a CombatResults parameter.
• Unit.GetCombatLosses: Changed name to EstimateLosses and return type from Point to CombatResults.
• WorldUtility: Moved several methods to new class Finder, and renamed several methods that find minima or maxima.
• World.Commands: Appended “Command” to the names of all concrete Command classes.

Hexkit Game & Hexkit Editor:

• Added “trustInfo” element to manifest files. Supposedly this makes Vista happy if you have UAC enabled (I don’t).
• Dialogs for recoverable exceptions (XML files, rule script, computer player) are resizable and show any inner exceptions and the stack trace.
• When variable modifier values are zero, they are preceded by a plus-minus sign (±).
• View menu: Added Center Site command (shortcut C) that centers the default map view on the selected site.

Hexkit Game:

• Known Issue (fixed in 4.0.1): The GUI does not respond while automated commands are being executed during the human player’s turn. This can get annoying when numerous units are retreating in the Crécy scenario. Solution postponed until Hexkit has been moved to VS2008 and XAML. In the meantime, consider increasing the Replay Speed.
• When a faction owns multiple units of the same class at the start of a game, any default-named units will receive unique names (with an appended instance count), even if the faction cannot build new units of that class.
• Property List (= entity statistics): Resources appear before abilities, and a unit’s strength resource appears before its other resources. This ensures that the most important mutable data is visible without scrolling.
• Game menu:
  • Select Next Unit (N): Changed name to “Wait & Cycle Units (W)” and ensured that active units have valid targets. The new hotkey W matches the Civilization key layout and is easier to reach than N.
  • Added command “Skip & Cycle Units (Space)” which acts like “Wait & Cycle Units” but also removes the selected unit from the Wait cycle during the current turn.
  • Added command “Unskip All Units (Ctrl+U)” which adds all skipped units back to the Wait cycle.
• Command menu:
  • Attack Site & Move Units: Always show dialogs since the new right-click mechanism (see below) now provides target selection directly on the default map view.
  • Manage Entities: Entities are sorted in natural order (first alphabetically by name, then numerically by instance count).
• Replay: Replay Speed:
  • Slow & Fast: Speed of map view events (such as movement animation) is halved or doubled, respectively, both for immediate human player commands and for replayed computer player commands.
  • Fast & Turbo: Briefly highlight the source & target sites of replayed computer player commands.
• Info: Faction Ranking:
  • Switching tab pages retains the selected comparison criterion, if possible.
  • Graph page: Fixed handling of values greater than 10,000.
• Fixed missing decimal places when showing variable values with a non-default display scale.
• Fixed crash when attempting to valuate a site when the current scenario has zero valuation for all sites.

Hexkit Editor:

• Known Issue (fixed in 4.0.0): Images page: Images are sorted lexically by identifiers, which puts “image-10” before “image-2”. Using a natural sorting order is unexpectedly difficult because the underlying ListBox class supports neither custom sorting nor a virtual mode, and the ListView class does not support the required display style. Solution postponed until Hexkit has been moved to VS2008 and XAML.
• Images, Variables & Entities page: Change Identifier automatically resorts the list view.
• Change Entity & Faction: Variables page: Double-clicking on an available variable has the same effect as the Add Basic button.
• Change Entity: Other page: Reorganized class-specific options into a separate group box.
• Areas page: Units owned by the first faction now show a flag in their regular faction color, not the ivory color that denotes active units in Hexkit Game.
• Fixed crash when loading a scenario whose entities reference undefined variables. Any such variables will not appear in the Editor GUI until they have been defined on the Variables page.

Added right-click shortcut for Attack and Move commands.

• When a friendly unit is selected, all possible attack & movement targets are highlighted automatically.
• Right-click on a target site to immediately issue the appropriate command for the selected unit only.
• Hold down Shift to show potential targets and issue commands for all eligible units in the selected site.
• When a right-click command has been executed, the selection automatically jumps to the next owned unit that still has valid attack or movement targets.

Units may move across sites they cannot occupy.

• The AStar and Coverage algorithms provided by Tektosyne 3.4.0 implicitly support a distinction between intermediate and ending locations of a movement path. See the Tektosyne WhatsNew file, the Class Reference, and the Hexkit User’s Guide for details on the new pathfinding model.
• Example: To simulate realistic archer formations, one hexagon in the Crécy scenario may contain only 100 archers, even though the maximum is otherwise 800 men. 52 archers may move through hexagons with 748 men or less, regardless of how many archers are present, but they may only end their move on a hexagon that contains at most 48 other archers.
• World.Unit:
  • CanMakeStep: Changed default implementation to also fail if target contains alien units. This was formerly tested by calling CanOccupy.
  • CanOccupy: Changed default implementation to always return true. Tests for transient occupation are now performed by CanMakeStep.
  • Removed obsolete method GetPartialOccupation.
• World.UnitAgent: Removed obsolete property PartialOccupation.

Added line-of-sight option to ranged attacks.

• You can now specify that ranged units must have a clear line of sight to their targets, and you can determine which entities obstruct this line of sight. We use the new Visibility algorithm provided by Tektosyne 3.4.0 as described in the Hexkit User’s Guide.
• Hexkit Editor: Change Entity: Other page: Added Blocks Attack ability and Ranged Attack option.
• Hexkit.Scenario.xsd:
  • Added boolean attribute “blocksAttack” (default true) to complex type “entityClass”.
  • Added enumeration “targetMode” and optional enumeration attribute “rangedAttack” to complex type “unitClass”.
• Scenario.EntityClass: Added boolean property BlocksAttack (default true).
• Scenario.UnitClass: Added enum TargetMode and enumeration property RangedAttack.
• World.Entity: Added property BlocksAttack which forwards to EntityClass property.
• World.Site: Added property BlocksAttack which aggregates the BlocksAttack values of all local entities.
• World.Unit:
  • Added property RangedAttack which forwards to UnitClass property.
  • Changed both CanAttackTarget overloads to use Visibility algorithm and Site.BlocksAttack if RangedAttack is Line.

Added negative ability that limits combat units to passive defense.

• You can now specify that combat units cannot actively attack during their turn, but only passively defend against attacks during other factions’ turns.
• Hexkit Editor: Change Entity: Other page: Added Can Defend Only ability.
• Hexkit.Scenario.xsd: Added boolean attribute “canDefendOnly” (default false) to complex type “unitClass”.
• Player.Seeker: With poor combat odds, would-be attackers wait a turn for support units only if all targeted defenders have the CanDefendOnly ability; otherwise, they attack preemptively.
• Scenario.UnitClass: Added boolean property CanDefendOnly.
• World.Faction.BeginTurn: Clears CanAttack flag of all owned units whose class specifies CanDefendOnly.
• World.Unit: Added boolean property CanDefendOnly which returns false if IsCombat is false, and otherwise forwards to UnitClass property.
• Roman Empire Scenario: Set CanDefendOnly flag for Militia and Milita (Wild) classes, removed obsolete CanAttack manipulation from CustomFaction.BeginTurn override.

Added default implementations for common attributes & resources.

• You can now directly specify several variables related to movement and combat, without having to write rule script code to express these relationships.
  • The attribute that represents the difficulty of moving across a terrain.
  • The attribute that represents a terrain’s elevation, e.g. above sea level.
  • The attribute that represents a unit’s maximum attack range.
  • The attribute that represents a unit’s maximum movement range.
  • The resource that represents a unit’s current morale.
  • The resource that represents a unit’s current strength or health.
• Hexkit Editor: Change Entity: Other page: Added options for Difficulty Attribute, Elevation Attribute, Attack Range Attribute, Movement Attribute, Morale Resource, and Strength Resource.
• Hexkit.Scenario.xsd:
  • Added optional elements “difficultyAttribute” and “elevationAttribute” to complex type “terrainClass”.
  • Added optional elements “attackRangeAttribute”, “movementAttribute”, “moraleResource”, and “strengthResource” to complex type “unitClass”.
• Scenario.TerrainClass: Added string properties DifficultyAttribute and ElevationAttribute.
• Scenario.UnitClass: Added string properties AttackRangeAttribute, MovementAttribute, MoraleResource, and StrengthResource.
• World.Site: Added integer properties Difficulty and Elevation that return the total difficulty and elevation of all local terrains, respectively. These values are cached while TerrainChanged is false.
• World.Terrain:
  • Added virtual property Difficulty whose default implementation returns the current value of the Attributes element indicated by DifficultyAttribute.
  • Added virtual property Elevation whose default implementation returns the current value of the Attributes element indicated by ElevationAttribute.
• World.Unit:
  • AttackRange: Renamed from MaxAttackRange, changed default implementation to return the current value of the Attributes element indicated by AttackRangeAttribute.
  • CanAttack: Only succeeds if Morale is greater than zero.
  • Movement: Renamed from MaxMoveCost, changed default implementation to return the current value of the Attributes element indicated by MovementAttribute.
  • Added virtual property Morale that returns the current value of the Resources element indicated by MoraleResource.
  • Strength: Renamed from CombatStrength, changed default implementation to return the current value of the Resources element indicated by StrengthResource.
  • Added virtual methods SetMorale & SetStrength whose default implementations change the value of the Resource element indicated by MoraleResource & StrengthResource, respectively.
  • CanOccupy: Changed default implementation to also fail if the Difficulty of the target site is zero.
  • GetStepCost: Changed default implementation to return the Difficulty of the target site, with a lower bound of one.

Added victory & defeat conditions based on total unit strength.

• You can now define optional victory & defeat conditions for each faction that are based on the total strength of its units, as opposed to the total number.
• Hexkit Game: Info menu: Show Factions & Show Ranking: Added rows for Unit Strength.
• Hexkit Editor: Change Faction: Conditions page: Added controls for Unit Strength.
• Hexkit.Scenario.xsd: Added value “UnitStrength” to enumeration type “conditionParameter”.
• Scenario.ConditionParameter: Added enumeration value UnitStrength.
• World.Faction: Added integer property UnitStrength that adds the Strength values of all owned Units.

Added Healing ability for unit classes.

• You can now inform computer player algorithms whether units can heal damage they have sustained. The actual healing mechanism must still be implemented separately.
• Hexkit Editor: Change Entity: Other page: Added Can Heal Damage option.
• Hexkit.Scenario.xsd: Added boolean attribute “healing” (default false) to complex type “unitClass”.
• Scenario.UnitClass: Added boolean property CanHeal.
• World.Unit: Added property CanHeal which forwards to UnitClass property.

Faction home sites are now optional.

• Faction home sites now default to undefined (-1,-1) rather than the map origin (0,0) and need not be defined.
• Hexkit Game:
  • When a faction without a home location becomes active, the map view attempts to center on the first active unit, the first inactive unit, or the first owned site, in that order.
  • After loading a saved game or executing a Begin Turn command for the local human player, the map view re-centers on the active faction’s initial site, as described above, and also attempts to select an active unit on that site.
• Hexkit Editor: Change Home Sites:
  • Button “Set As Home Site” changes to “Clear Home Site” when current home site is selected.
  • Double-clicking a selected faction reselects the faction’s home site, if any.
• Hexkit.Scenario.xsd: Changed element “factionSites” and nested element “homeSite” from required to optional.
• Scenario.Faction.HomeSite & World.Faction.HomeSite: May now return invalid coordinates.
• World.Finder: Added method FindFactionSite that attempts to find a faction-related site to center on.

Rule Script Changes:

• Added Visual Studio project Rules that contains all rule scripts. This project is not referenced by any other project, and all scripts except one must bet set to Build Action: None. When editing a specific rule script, set it to Build Action: Compile to enable IntelliSense for all Hexkit and Tektosyne types. The scripts were previously referenced as “solution items” which provide IntelliSense only for BCL types, and this proved quite cumbersome for complex scripts.
• Added command Automate that does nothing, and empty virtual method Faction.Automate that rule scripts may override to implement the desired automated action, e.g. with another inlined command. Use Automate with command queuing to automate actions that are not precisely known in advance.
• Added HCL instruction CreateFaction to explicitly start a faction’s history recording. BeginTurn automatically emits CreateFaction after Faction.Initialize has returned. This means that the first recorded history event now correctly counts Sites and Units, and the first column on the Faction Ranking: Graphs tab page no longer shows an ugly jump in the Roman Empire scenario. (The attempted fix for this issue in Hexkit 3.6.1 caused crashes during replays.)
• Added HCL instruction SetEntityClass to change the entity class of an existing entity without having to delete and recreate it. All flag values are retained, and values of existing resources are transferred. All other variables are reset to the default for the new entity class. Only classes of the same category are acceptable.
• Added static class World.Finder that contains proxies for all AreaSection properties related to pathfinding (MapGrid and the new algorithm properties), all static Unit methods, and several related WorldUtility methods. Rule scripts should prefer Finder properties over the corresponding AreaSection properties as the full names are much shorter.
• Added structure World.CombatResults containing the original strength and absolute & relative losses for both sides in an Attack command. All uses of Point values to hold combat losses have been changed to CombatResults, including the return value of the virtual method World.Unit.EstimateLosses.
• Added structure World.PlayerSettings containing a subset of player settings and algorithm options that is of interest to rule scripts, and delegate World.GetPlayerSettingsCallback that allows factions to retrieve their current PlayerSettings.
• World.Entity: Added object property Tag that provides temporary data storage for computer player algorithms. The value of this property is not cloned or persisted.
• World.Faction: Added properties GetPlayerSettings and PlayerSettings that allow rule scripts to retrieve the current PlayerSettings for the faction and adjust their behavior accordingly.
• World.IRulesFactory: Added method Initialize that allows initialization of private rule script data based on a fully created WorldState at the start of the game.
• World.Unit: Added Point parameter originalSource to virtual methods CanMakeStep & CanOccupy. This provides the original location of all units at the start of the Move command.
• World.Commands/Instructions: Appended “Command” to the names of all concrete Command classes, and “Instruction” to the names of all concrete Instruction classes. The new names are more readable and avoid clashes with popular method names. The semantics and XML names of the affected classes remain unchanged.

Computer Players:

• AlgorithmOptions:
  • Added integer property TargetLimit that defaults to eight. This option limits the maximum number of potential targets that should be examined for each unit, greatly accelerating target-rich scenarios like Crécy.
  • Added boolean property UseScripting that defaults to true. This option allows computer-controlled factions to selectively bypass custom scripted actions, or custom limitations of actions.
• AlgorithmGeneral:
  • Changed method AttemptAttack to allow attacks with small effect, even at positive odds, when counter-attacks are weak or nonexistent. Failure now requires not only defender losses smaller than 10% of the current odds, but also attacker losses greater than 10%. The other conditions are unchanged.
  • Added method CombatComparisonAbsolute to select attack targets based on absolute losses. This improves target selection in scenarios like Crécy where units cannot heal.
  • Added method CombatComparisonRelative to select attack targets based on relative (percentage) losses. This replicates the behavior of previous Hexkit versions.
  • Added method SelectCombatComparison that returns CombatComparisonRelative if a majority of units in the current scenario or world state have the Healing ability, and otherwise CombatComparisonAbsolute. See the Hexkit User’s Guide for the rationale behind these changes.
  • SelectAttackTarget & SelectMoveTarget: Added integer parameter maxTargetCount to limit how many of the specified targets are actually considered.
• Seeker:
  • Main loop skips waiting units while the world state remains unchanged, and terminates early if no reachable targets were found. This speeds up scenarios like Crécy where special conditions prevent numerous units from acquiring targets.
  • Added call to SelectCombatComparison before the main loop starts. The selected CombatComparison method is then used by all subsequent calls to SelectAttackTarget.
  • Supplied the current value of the TargetLimit option to all SelectAttackTarget & SelectMoveTarget calls.

Internal Changes:

• Added attribute [DebuggerStepThrough] to all trivial property getters & setters to simplify debugging.
• Editor: Deleted class AreaFill as Tektosyne.Mathematics.FloodFill now provides a more general solution.
• Players.Player: Changed Factions to a read-only collection. Use PlayerManager.SetPlayer to change a faction’s player assignment. This change allowed caching the current player assignment for GetPlayerSettings.
• Players.PlayerManager: Added public method GetPlayerSettings that conforms to the GetPlayerSettingsCallback delegate and returns a faction’s current PlayerSettings.
• Scenario.AreaSection: Added properties AStar, Coverage, FloodFill, and Visibility that return the eponymous graph algorithms for the current MapGrid. This was necessary since the algorithms are no longer provided by the PolygonGrid class itself. The algorithms are automatically recreated whenever the MapGrid changes.
• Scenario.EntityClass: Removed empty virtual properties CanCapture, CanRecover, IsBackground, and RangedAttack since the class got too crowded with these properties that only apply to derived classes.
• World.Entity: Changed internal method HasUniqueName into public property and added property UniqueNameSuffix that extracts the unique name suffix, if any.
• World.EntityHistory: Added event type SetClass that records the new HCL instruction SetEntityClass.
• World.Item/Special/Terrain/Unit: Added property Item/Special/Terrain/UnitClass that returns the same value as Entity.EntityClass but cast to the proper derived type.
• World.UnitAgent: Added Point property OriginalSource which holds the new originalSource parameter for Unit.CanMakeStep & CanOccupy while the AStar and Coverage algorithms are running.
• World.WorldUtility: Moved several methods to new class Finder, and renamed several methods that find minima or maxima – see Class Reference for details.

Version 3.6.2 (released 2007-08-20)

Breaking Changes

• The current map scale (submenu View: Zoom) is now stored as an XML attribute called “scale” rather than an XML element called “mapScale”. This causes an XML schema error when Hexkit Game or Editor attempts to load an existing options file. Just click OK and turn some map view option on and off to rewrite the file.
• Scenario Authors: Losing all territory is no longer a global default defeat condition. You must add this particular condition back to all your factions in Hexkit Editor.

DeBray Bailey Images:

• Added several image sets that combine multiple non-animated images whose identifiers differ only in their numerical suffix and which are suitable for random frame selection (see below). The image sets substitute “-set” for the suffix, and possibly “-set-subset” in the case of subsets.
• Roman Empire scenario: The barbarian forests use the new “image-terrain-grass-forest-set” image with random frame selection for some visual variety.

Hexkit Game:

• Fixed crash when attempting to load saved games. The redesign of history management in Hexkit 3.6.1 had skipped over some necessary initialization steps. Thanks to Ignacio Ruiz-De-Conejo for reporting this very embarrassing bug!

Hexkit Editor:

• Removed obsolete (and undocumented) terrain restriction: when attempting to add more than one terrain of the same class to the same site, only the first terrain would be created.
• Master page: The modification flag for the Master section is not properly reset at times, causing spurious warnings about unsaved changes. This is not fixed yet but I’m aware of the issue.
• Change Entity: Image page: Fixed display of animation mode for selected image.
• Images page:
  • When resizing the application window, the width of the image list now grows relatively faster than that of the Image File Path column, and the Image ID column remains fixed.
  • When reverting to the associated section file, the currently selected index in the image list is reselected.
• Areas page:
  • When the map contents are saved to XML, all sites with identical contents are packed into a single “area” element. Previously, sites with non-terrain entities were not considered for area packing.
  • Fixed crash when attempting to edit entity instances without a valid entity class.
  • Site Edit Mode: Correctly reset to Modify whenever the map view is regenerated.
  • Change Site: Other page: Automatically selects the first category that contains any local entities, if any.

Variable values may be shown directly on the map view.

• Game & Editor: Added menu item View: Show Variable which displays the new Show Variable dialog.
• You can show basic values, modifier values, or both of any attribute or resource.
• You can choose a numeric display, a lighter or darker shading incidating relative values, or both.
• Each map site shows the sum of the selected variable values for all present entities.

Added customizable victory & defeat conditions.

• Factions may specify individual conditions based on reaching a given number of sites, units, and/or game turns. Such conditions are commonly used in wargames. Global resource-based conditions are still available as well.
• Hexkit Game:
  • Faction Status: Added Conditions page showing victory & defeat thresholds for all victory conditions that apply to the selected faction.
  • Faction Ranking: Tables page: Thresholds for Sites and Units conditions are shown if they apply equally to all factions, otherwise an asterisk.
• Hexkit Editor:
  • Change Faction: Added Conditions page with controls for new victory & defeat conditions.
  • Change Faction: Other page: Renamed to Computer page, as it only hosts computer player options.
• Hexkit.Scenario.xsd: Added optional nested elements “victory” and “defeat” to complex type “factionClass”.
• Scenario:
  • Added struct Condition and enumeration ConditionParameter.
  • FactionClass: Added collection properties VictoryConditions and DefeatConditions.
• World.Faction: CheckVictory and CheckDefeat now check the VictoryConditions and DefeatConditions, respectively, of the underlying FactionClass. The default defeat condition (Sites == 0) was removed.

Added options to customize entity templates.

• Entity templates may change the variables of their underlying entity class. This includes basic values and modifiers but not build resources. You cannot add new variables or delete existing variables.
• Entity templates may specify random frame selection. When a non-animated entity is instantiated, this flag causes Hexkit to randomly select one of the available image frames.
• Hexkit Editor: Added new Change Entity Instance dialog which is available wherever entity templates can be created. The existing Change Entity dialog was renamed to Change Entity Class for clarity.
• Hexkit.Scenario.xsd: Added optional attribute “randomFrame” and optional nested elements “attribute(Modifier)”, “counter”, and “resource(Modifier)” to complex type “entity”.
• Scenario.EntityTemplate: Added boolean property RandomFrame and dictionaries for all variables and variable modifiers.
• World.Entity: Added property EntityTemplate that retains original template for easy roundtripping. In Hexkit Editor, this is actually a clone of the original template since the packing algorithm of the Areas section may create multiple sites from a single template.

Internal Changes:

• Hexkit.Options assembly: Cleaned up internal structure without changing the user experience.
  • Hexkit.Graphics now depends on Hexkit.Options, rather than the other way round.
  • Map views automatically load any available settings upon creation, and automatically save any changed settings to disk.

Version 3.6.1a (released 2007-05-25)

Compatibility fixes only, no functional changes.

• Hexkit appears to work fine on Windows Vista. The ReadMe file was updated accordingly.
• Changed manifest files for Hexkit Game and Hexkit Editor to reference the 64-bit version of the Common Controls library when running on 64-bit Windows. Previously, trying to run either application on 64-bit Windows would generate a meaningless error message.
• On 64-bit Windows for the AMD64 architecture (which also includes all 64-bit Intel CPUs except Itanium), the binary package now installs to the regular Program Files directory by default, not the Program Files (x86) directory for 32-bit applications.
• Fixed NAnt build file for compatibility with 64-bit Windows. This comprised eliminating the broken “sysinfo” task and looking for 32-bit tools (HTML Help Compiler, Inno Setup) in Program Files (x86) if this directory exists.

Version 3.6.1 (released 2007-05-16)

• Updated Hexkit User’s Guide to reflect the current Hexkit release.
• Upgraded binary package to Inno Setup 5.1.12 which should work better on Windows Vista.
• Roman Empire Scenario: Neutral Armies are weaker and consume more population.
• Fixed potential crashes upon application exit when an animated map view is destroyed while the animation timer is still active.
• ReadMe: Janis Bridges notified me of two issues concerning the source package.
  • Very long path names: Visual Studio 2005 may have trouble with file paths longer than 140 characters or so. If you experience problems building the solution, try unpacking the archive to a shorter path. (Update: The problem wasn’t very long paths but paths containing spaces, see version 3.7.1)
  • Visual C# Express: This free edition of Visual Studio appears to work with Hexkit, but you won’t have convenient access to “solution items”, i.e. files that are not part of any project.

Hexkit Game:

• Delayed the start of history recording for factions & entities until the first Begin Turn command. This speeds up scenario initialization and prevents big jumps between the first and second data point on the Faction Ranking: Graphs tab page.
• Fixed unintentional selection of event view panel after command execution that would swallow menu shortcuts.

Hexkit Editor:

• Change Connections: Edited frame is now drawn with proper scaling.
• Change Entity: Dialog width increases temporarily when Image page is selected, making room for a larger image list box and clearer control grouping.

Changes to DeBray Bailey Images:

• Added Stretch scaling to all identifiers in the “image-split” namespace.
• Added Stretch scaling and fully specified frame connections to all identifiers in the “image-river” and “image-road” namespaces that did not already use scaling.
• The resulting images are quite ugly but immediately usable for square-on-edge maps. For better visual quality, create an individual entity class for each variant frame. Use the new image stack options to disable scaling & connections on each stack entry as required.
• Removed spurious “connections” attributes on several unconnected frames.

Added options to customize an entity’s image stack.

• The Unconnected option ignores all neighbor connections defined by an entry’s image frames. This allows you to use connected frames (currently roads & rivers) without adding their connections to the combined image stack.
• The Unscaled option ignores the ScalingX/Y values specified by the associated image. This allows you to use the bitmap tile of a scaled image without obscuring the entire map polygon.
• Hexkit.Scenario.xsd: “imageStack”: Added boolean properties “unconnected” and “unscaled”.
• Scenario.ImageStackEntry: Added boolean properties UseUnconnected, UseUnscaled, IsImageUnconnected, and IsImageUnscaled.

Internal Changes:

• Scenario.EntityClass: Renamed property Images to ImageStack to reflect element type.
• Scenario.ImageStackEntry: Renamed property Scaling to ScalingVector to avoid confusion with ImageScaling properties.
• World.Site.IsConnected: Allowed prefix matches for entity class identifiers. This allows different entity classes (whose identifiers are distinguished by suffixes) to represent different aspects of the same conceptual game entity.

Version 3.6.0 (released 2007-04-30)

• ReadMe: Admitted that the minimum resolution is now actually 800 x 600 rather than 640 x 480, due to many oversized dialogs…
• Updated NAnt.build for NAnt 0.85 final.
• Fixed nonfunctional scrollbars of all independent scrollable bitmap views (catalogs, image files).

Breaking Changes for Scenario Authors

• Image Section: Change value of attribute “image.animation” from “true” to “Random”.
• Image Section: Replace attribute “image.background” with new attributes “scalingX” and “scalingY”, each with value “Repeat”. In the Entity Section, add new attribute “background” with value “true” to any “terrainClass” element that makes use of such images.
• Area Section: Change name of element “areaClass” to “area”.

Hexkit Game:

• Hexkit Game: The “invalid” icon (a red circle with a slash) is always added to the bitmap catalogs, not just in Editor mode. A missing bitmap file may cause this icon to appear on the map view or elsewhere, but will no longer throw an exception.

Hexkit Editor:

• Changed tab page shortcuts from Alt to Control combinations, and assigned some useful controls within tab pages to Alt combinations.
• Add Image, Add Entity, Add Frame, Add Faction, Add Variable: New item is initialized with data of selected list item. This greatly simplifies the creation of similar items.
• Images page: Changing an identifier automatically re-sorts the Image list.
• Entities page: Image preview is automatically updated to reflect changes made on other tab pages.
• Areas page:
  • Added new Site Edit Mode “Fill” to fill a contiguous area of identical sites with the contents of the selected site.
  • Fixed crash due to buggy display-to-map coordinate conversion with certain map geometries.
• Change Entity: Image page: Added Find button to locate the selected entry in the Available Images list.
• Change Frame: Double-clicking a frame immediately selects it and closes the dialog.

Changes to DeBray Bailey Images:

• Added identifiers for all remaining bitmap tiles, increasing the total number of image frames from ~800 to ~2,000. This required an overhaul of the naming scheme for image identifiers, and many identifiers for existing images have changed. The new naming scheme is described in the Hexkit User’s Guide.
• Added white & black horses and isolated front parts of all horses to existing PNG file “db npcs.png”. This is for putting riders on horses, as described in the Hexkit User’s Guide.
• Added Stretch scaling in both dimensions to all hexagon roads & rivers, and updated all image attributes to new schema as appropriate.
• Fixed size declaration for all bitmap tiles except hexagon roads & rivers. They are actually 24x35 pixels but were declared as 26x37 pixels. The extra pixel of transparency on each side had no visual effect so far but would interfere with the new scaling options.
• Re-encoded all PNG files using Ken Silverman’s PNGOUT compressor (comes with IrfanView) for a total space saving of 300 KB.

Added options to customize image animation.

• Images now have an Animation option with the following possible values:
  • None (the default) disables animation. This is equivalent to disabling the obsolete boolean Animation option.
  • Random starts the animation sequence at random intervals. With Sequence.Random (the default), this is equivalent to enabling the obsolete boolean Animation option.
  • Continuous restarts the animation sequence as soon as it has finished.
• Images now have a Sequence option with the following possible values:
  • Random (the default) shows a random single frame and then terminates the sequence.
  • Forward & Backward show all frames in forward or backward direction, respectively.
  • Cycle shows all frames in forward direction, then again in backward direction.
• Sequence values other than Random allow the creation of multi-frame animation sequences that are played back sequentially.
• Hexkit Editor: Change Image: Added Animation and Sequence options.
• Hexkit.Scenario.xsd:
  • Added enumerations “animationMode” and “animationSequence”.
  • “image”: Replaced boolean attribute “animation” with enumeration attributes “animation” and “sequence”.
• Hexkit.Graphics assembly:
  • Removed obsolete enumeration FrameCategory.
  • MapViewPanel: Animation now directly modifies the FrameOffset value of an animated World.Entity. This is the most efficient way to record the current animation phase.
• Hexkit.Scenario assembly:
  • Added enumerations AnimationMode and AnimationSequence.
  • Image & EntityClass: Replaced boolean property IsAnimated with enumeration properties Animation and Sequence.

Added options to customize image scaling.

• Images now have ScalingX and ScalingY options with the following possible values:
  • None (the default) disables scaling. This is equivalent to disabling the obsolete Background option.
  • Repeat repeatedly copies each frame to fill a map polygon. This is equivalent to enabling the obsolete Background option, but no longer implies a background terrain. Instead, the Background flag must now be set on the specific terrain class itself. It no longer corresponds to any specific images.
  • Stretch grows or shrinks each frame to fit a map polygon. This is intended for images that are drawn for a specific polygon size, notably roads & rivers which are too broad for small hexagons and too short for large hexagons. Stretch allows the use of these images with maps of any hexagon size.
• Since individual images are no longer considered background terrains, you can now use images with Repeat or Stretch scaling at any place within an image stack. This allows you to create semi-transparent overlays that cover an entire map polygon.
• To support Stretch, the master bitmap catalog is now created using GDI+ functions rather than direct bitmap manipulation. The graphics engine therefore takes a bit longer to initialize, but that shouldn’t be noticeable on most systems.
• Hexkit Editor:
  • Change Image: Added X-Scaling and Y-Scaling options.
  • Change Entity: Other page: Added Background Terrain option.
• Hexkit.Scenario.xsd:
  • Added enumeration “imageScaling”.
  • “image”: Replaced boolean attribute “background” with enumeration attributes “scalingX” and “scalingY”.
  • “terrainClass”: Added boolean attribute “background”
• Hexkit.Scenario assembly:
  • Added enumeration ImageScaling.
  • Image: Replaced boolean property IsBackground with enumeration properties ScalingX and ScalingY.
  • EntityClass: Removed background optimization for Images since individual images no longer represent background terrains. Background optimization remains in place for EntityTemplate and Entity objects.
  • TerrainClass: Made boolean property IsBackground writable.

Images may draw frames from different source files.

• There were some related bitmap tiles in different PNG files which logically belonged in the same image, so now we can do that without merging the files themselves.
• Hexkit Editor: Change Image: Source file is recorded separately for each frame.
• Hexkit.Scenario.xsd:
  • “image”: May contain multiple consecutive sequences of “source” and “frame” elements.
  • “source”: Valid for all following “frame” elements, until the next “source” element.
• Scenario.Image: Moved property Source and related validation logic to ImageFrame.

Entity classes may use multiple images with multiple frames each.

• This functionality is essential for animated units that require multiple images, such as riders on horses or soldiers wielding crossbows.
• The total entity frame count equals the maximum frame count of any image. An entity frame combines all image frames at the same index position. For images with less than the maximum frame count, the index simply wraps around to zero.
• The animation options for the entity class equal the highest settings specified by any image that contributes at least two frames to the image stack.
• Hexkit.Scenario.EntityClass:
  • Animation and Sequence return the highest values of any multi-frame element in the Images collection.
  • FrameCount is now set automatically by Validate, and returns zero (rather than one) until successful validation. Clients must take care to check FrameCount for zero before using it in display code.
  • Added method GetConnections that returns the merged ImageFrame.Connections for the same Frames index of all Images elements. Mirrored images result in mirrored Connections.

Entity classes may specify pixel offsets, mirror settings, and frame usage for each image.

• This functionality is essential for composite images since individual stack entries are unlikely to fit together nicely without modification.
  • Pixel offsets shift the image from its default position in the center of the polygon.
  • Mirroring flips the image across the horizontal and/or vertical axis. This is internally represented as scaling by a factor of -1.
  • Multi-frame images may use only a single frame instead of all frames. The resulting image stack entry appears as a non-animated image with a frame count of one.
• The image stack of an entity class may contain multiple entries for the same image, allowing different positioning, mirroring, and/or frame usage settings for each entry.
• Hexkit Editor:
  • Change Entity: Image page: Added controls to specify pixel offsets, mirror settings, and frame usage for each image.
  • Change Frame: Supports both entity templates and image stack entries.
• Hexkit.Scenario.xsd:
  • Added complex type “imageStack” that combines IDREFS with an optional “frame” attribute and optional nested “offset” and “scaling” elements.
  • “entityClass”: Changed nested element “images” to complex type “imageStack”.
• Hexkit.Scenario assembly:
  • Added structure ImageStackEntry that groups an Image reference with Offset, Scaling, and SingleFrame properties.
  • EntityClass: Changed Images collection to hold ImageStackEntry instances rather than Image references. Many changes throughout Hexkit to reflect this change.

Terminology Changes:

• Renamed Scenario.AreaClass to Area and corresponding XML element “areaClass” to “area”. There are no “Area objects” in the World assembly so the “Class” suffix had to go.
• Renamed Scenario.EntityImage to Image. I hesitated with this decision due to the naming clash with System.Drawing.Image but it’s really the only name that makes sense.

Internal Changes:

• World.Entity.DisplayClass: Changing this property (directly or via HCL instruction) also resets FrameOffset to zero. This guarantees that the FrameOffset is valid for the new DisplayClass.

Version 3.5.2 (released 2007-01-07)

• Added note regarding .NET Security Permissions to ReadMe file and installation process. Hexkit requires “Full Trust” permissions, so you’ll get an incomprehensible error dialog if you attempt to run the Hexkit executables over a shared network drive.

Hexkit Editor:

• Change Geometry: Fixed crash when resizing to less than one row or column. Tool tips and range checks are now dynamically updated to reflect the legal range. Thanks to Thomas C. Hudson for the bug report that triggered the investigation!
• Areas page: Fixed terrain packing bug that added the default terrain stack to individual Area objects and their XML representation.

Version 3.5.1 (released 2006-11-05)

• Updated to Tektosyne 3.3.0 with renamed Utility classes and new A* pathfinding option.
• Updated Hexkit User’s Guide to new version, and changed diagram font to Lucida Sans with real cursive and bold typefaces!

Troll Chess scenario:

• Changed map geometry to squares on edge. This demonstrates the new variable geometry and fits the chess theme better.
• Enabled new A* pathfinding option UseWorldDistance to straighten movement paths.

Hexkit Game: Fixed crash when attempting to show Faction Status dialog.

Internal Changes:

• Hexkit.Scenario.xsd: Fixed element “variableClass.range” being mandatory instead of optional.
• Prefixed all Utility classes with their enclosing namespace for disambiguation.

Version 3.5.0 (released 2006-10-08)

• Allowed image frame size to exceed polygon size in either or both dimensions. In that case, only the central image section is shown, clipped to the polygon outline.
• Fixed mutex bug that prevented Hexkit Game and Hexkit Editor from running at the same time.
• Fixed screen & disk output of application title to read “Hexkit Game” or “Hexkit Editor” rather than just “Hexkit”.
• Roman Empire scenario: Fixed crash when cities of defeated faction revert to Barbarian rule. Thanks to Wallace Wood for this bug report!

Hexkit Game:

• Fixed crashes when attempting to show error dialogs while loading a saved game in a background thread.
• Fixed incorrect exception type thrown on command failure (KeyNotFoundExcpetion instead of InvalidCommandException).

Hexkit Editor:

• Fixed window caption not showing title of current scenario.
• Section Location: Changing subsection locations now correctly marks the Master section as changed. The text box for the file path is now read-only, as stated in the help file.
• Images page: Fixed identifier labels and display corruption. Also ensured that selected image is always visible.
• Areas page: Fixed crashes when clearing owner of sites with default-owned units, and when placing default-owned units on unowned sites.

Added support for squares and hexagons with variable orientation. This includes the changes listed below, but also secondary changes throughout Hexkit.

• Hexkit.Scenario.xsd:
  • Changed enumeration “hexagonEdge” to “compass” with additional North and South directions.
  • Added elements “areas.mapGrid” and “areas.polygon” with a variety of simple types describing polygon attributes.
  • Deleted simple type “hexagonSide” and obsolete elements “areas.map” and “images.hexagon”.
• DeBray Bailey Images:
  • Added images for rivers & roads that fit hexagons lying on an edge. The bitmap tiles were added to the existing PNG files, “hexagon rivers.png” and “hexagon roads.png”, and the image frame coordinates are stored under the identifiers “image-river-hexagon-edge” and “image-road-hexagon-edge”.
  • Changed identifiers of existing river & road images that fit hexagons standing on a vertex to “image-river-hexagon-vertex” and “image-road-hexagon-vertex”.
• Hexkit Editor: Areas page: Renamed Change Map Size dialog to Change Map Geometry, and added a new Structure tab page to determine the geometric structure of the game map.
• Hexkit.Graphics: Selection frames are now drawn by MapViewPanel as GDI+ decoration. They no longer appear in the scaled bitmap catalogs created by MapView instances.
• Hexkit.Scenario:
  • Moved all map geometry from ImageSection to AreaSection, please see Class Reference for details.
  • ImageFrame: Changed property Connections to collection of Tektosyne.Drawing.Compass values.

Terminology Changes:

• When referring to places on the map, the term “site” is now generally used instead of “hexagon” or “location”. Hexagon is too specialized since we can also have squares, and locations are attributes of sites.
• Hexkit.Scenario.xsd:
  • Renamed “entityClassLocations” to “entitySites” and nested element “place” to “placeSite”.
  • Renamed “factionLocations” to “factionSites” and nested element “home” to “homeSite”.
• Hexkit.Session.xsd: Renamed “insImage.location” to “insImage.site”.
• Please refer to the Class Reference for many similar changes in the C# source code.

Internal Changes:

• Added type suffixes to the names of all scenario files (XML and C#): Rules, Images, Areas, Entities, Factions, Variables. This should reduce confusion while editing these files.
• Hexkit.Scenario.xsd: Revised complex types “variableClass” and “resourceClass”.
  • Moved attributes “minimum”, “maximum”, and “scale” to nested element “range”.
  • Changed elements “defeat” and “victory” to attributes of nested element “condition”.
  • Moved attributes “limit” and “reset” to nested element “modifier”.
• Hexkit.World.Site:
  • Added SiteConnection parameter to method IsConnected. You can check specifically for a connected Entity on the current Site, on the current or the neighboring Site, or on both the current and the neighboring Site (i.e. the original behavior).
  • Added implicit operator Point(Site). Valid Site objects are converted to their Location, and null references are converted to InvalidLocation. You can now supply Site references to methods that expect a Point value.
  • InvalidLocation: Guaranteed to be identical with Tektosyne.Drawing.PolygonGrid.InvalidLocation so that the two fields can be used interchangeably.

Version 3.4.3a (released 2006-08-28)

Hexkit Game: Fixed display of attack arrows which apparently hasn’t worked for over a year!

Version 3.4.3 (released 2006-05-08)

• Added Help menu items to show ReadMe and WhatsNew files, and merged About Hexkit Game/Editor dialogs into About Hexkit dialog.
• Fixed display not adapting to Windows system font size. This feature was broken since 3.4.0 due to an incorrect DialogFont in Tektosyne 3.0.0 which had been fixed in 3.1.0.

Internal Changes:

• Global.Strings.resx: Updated to Microsoft ResX Schema 2.0 and added auto-generated Strings class with strongly-typed resource properties. A build-time hack elevates the default visibility of this class, as described in the ReadMe file.
• Deleted superfluous “new FooEventHandler(…)” statements which C# 2.0 generates automatically.
• Renamed all System.Drawing.Graphics variables from “paint” to “graphics”, for conformance with other variable names.
• Global.RM: Moved FormatHexagon/Location to Global.Controls and deleted empty class.
• Scenario.EntityTemplate: Changed all null comparisons with object casts to Object.ReferenceEquals calls. The method call is more readable and gets compiled to the same optimized code.

Version 3.4.2 (released 2005-12-22)

Hexkit Game: Ignore warnings when compiling rule script in release mode

Hexkit Editor:

• Fixed several crashes when accessing unavailable data
• Master: File: New: Clears all subsection file paths
• Areas page: Fixed drawing of unvailable frames

Version 3.4.1 (released 2005-12-08)

• Published updated and revised Hexkit User’s Guide
• Changed entity resource updates to match new Hexkit User’s Guide

Internal Changes:

• Graphics: Renamed MapViewBase/Client/Server to CatalogManager/MapView/MapViewManager
• Players: Removed “Base” suffix from classes AlgorithmBase and PlayerBase
• World: Removed “Base” suffix from Commands.CommandBase and Instructions.InstructionBase
• World.Faction.BeginTurn: Replaced unreliable ActiveFactionIndex with NewTurnStarted
• World.WorldState: Added property NewTurnStarted

Version 3.4.0 (released 2005-10-30)

• Upgraded solution to Microsoft .NET Framework 2.0
• Moved user settings and saved games to My Documents folder
• Hexkit.Help:
  • Changed to C# project with customized MSBuild targets
  • Added style sheet and HTML files to HTML Help project file
  • Reorganized HTML files into topical subdirectories

Roman Empire scenario:

• Fixed resignation event for factions that can resign
• Neutrals can build mobile armies of skirmisher quality
• Tripled population production for barbarian hovels

Hexkit Game:

• Records lifetime events for all factions and entities
• Fixed multithreading bug when starting or resuming game
• Game menu:
  • Revised Player Setup dialog, added computer player options
  • Removed Auto-Place Units, obsoleted by Build Entities
• Command menu:
  • Changed Build Units to Build Entities
  • Added Manage Entities & Hexagon Entities
  • Removed Disband Units & Place Units, obsoleted by Manage/Hexagon Entities
• Info menu:
  • Faction Status:
    • Shows both dead and surviving factions
    • Shows hexagon counts and owned entities of any category
    • Shows available classes of all categories
  • Faction Ranking: Added Graphs tab page with history graphs
  • Placement Locations: Shows only classes with at least one placement location
• Debug menu: Added Show Event History dialog to show recorded events

Hexkit Editor: Change Faction: Added Other tab page for customized computer player

Game Commands:

• All commands except Begin/EndTurn may be issued for non-active faction
• Added Rename to change names of owned unit, item & terrain entities
• Build, Place: Extended to items & terrains
• Disband: Renamed to Destroy, extended to items & terrains
• Resign: May be queued, but does not take effect until EndTurn

Computer Players:

• Added two basic options, Random Building and Random Placement
• Simplified computer player assignment to factions (now one-to-one)
• Scenario designer may customize each faction’s computer player
• Renamed algorithm Search & Destroy to Seeker (less bombastic and more descriptive)

Entities & Entity Classes:

• Changed entity category sequence to Unit, Item, Terrain, Special
• DefaultPlace flag defaults to false for all entity classes
• Valid placement locations are determined by EntityClass, not Entity
• Items & Terrains: May be built, placed, and destroyed if allowed by scenario

Internal Changes:

• Images section: Bitmap file paths are relative to parent folder of Images
• Global.RM: Removed GetString(String, CultureInfo) to reduce FxCop errors
• Options.ComputerLevel: Added Custom value for user-defined settings
• Players.AlgorithmGeneral.BuildRandom: Fixed random range bug
• World.Command/Instruction: Renamed to Commands/Instructions
• World.Commands.CommandBase.Instructions: Renamed to Program
• World.Utility.GetAllPlaceTargets: Returns only classes with at least one target

Version 3.3.0 (released 2005-06-03)

• Application checks that each user runs only a single instance
• Changed most Control.Resize events to Control.Layout
• Fixed map view animation which mysteriously ceased working
• Resized several dialogs and list view columns

Roman Empire scenario:

• All factions accumulate population resource
• Population expended for automatically created units
• Barbarian hovels reinforce only barbarian hordes
• Tweaked town productions and militia strength

Hexkit Game:

• Games start in a background thread with a status dialog
• Removed redundant progress bar from status bar
• Fixed exception when accessing non-unit entities in replays
• Refactored into new classes EventDisplay, HumanAction, Dialog.CreateSession

Hexkit Editor:

• Progress bar shows progress while map view is recreated
• Changing placement locations marks Entities section as changed to record default placement flag

Hexkit Command Language:

• Removed redundancy check which was too much trouble for too little gain
• Replaced instruction SetFactionResource with SetFactionVariable
• Replaced instructions SetEntityAttribute and SetEntityResource with SetEntityVariable
• Added instructions SetFactionVariableModifier and SetEntityVariableModifier
• Instruction SetEntityVariable now accepts non-unit entities
• Removed instructions UpdateFactionResources and UpdateUnitResources
• Removed instruction SetTerrainChanged (now triggered automatically)

Rule scripts:

• Changed factory pattern to use a single factory class
• Renamed default rule script to “Default Rules.cs”
• Added prefix Custom to classes that derive from World classes

Saved games:

• Renamed Hexkit.Configuration.xsd to Hexkit.Session.xsd
• Changed namespace to Hexkit.Session
• Changed top-level element to “session”
• Serialization now controlled by Hexkit.Game.Session

Scenario terminology:

• Renamed Document/Scenario section to Master section
• Renamed [Content] Classes section to Entities section
• Renamed Properties section to Variables section
• Section classes are now AreaSection, EntitySection, FactionSection, ImageSection, MasterSection, VariableSection
• Renamed ContentClass to EntityClass, ImageObject to EntityImage, Property to VariableClass, etc.
• Added suffix Class to all classes that are “instantiated” by World classes

Scenario semantics:

• EntityClass: Added dedicated BuildResources collection for build costs
• FactionClass: Replaced UnitClasses with BuildableUnits
• ItemClass: Added CanRecover ability to match UnitClass.CanRecover
• UnitClass: Removed owner-independent CanBuild ability
• VariableCategory: Added Counter category for persistent values that are invisible to the player
• VariableClass: Fixed and enhanced formatting of instance values

World terminology (formerly Configuration):

• Renamed assembly & namespace Hexkit.Configuration to Hexkit.World
• Renamed Document to WorldState, ContentBase to Entity, MapHexagon to Site, etc.
• Removed suffix Base from all classes that are specialized by the rule script

World semantics (formerly Configuration):

• Added class Variable with initial and current values of one numerical variable
• Added class VariableContainer to manage a collection of Variable objects
• Added class EntityClassCache to store initial scenario values for entity variables
• Entity: Added methods OnOwnerChanged and OnSiteChanged that execute when the property has changed
• Entity/Faction: Added method OnVariableChanged that execute when a variable value has changed
• Terrain/Special: Owner property now equals Site.Owner of current Site

Variable semantics (i.e. numerical properties):

• Variable modifiers are now themselves modifiable
• All entities have a full set of numerical variables:
  • Non-unit entity attributes have no defined semantics by default
  • Non-unit entity resources are:
    • modified by same entity only, at the beginning of each turn
    • transferred to local units if possible, at the beginning of each turn
    • transferred to owner only for recoverable items, when recovered
• Special rules for items:
  • Placed items modify themselves if possible, else all local units
  • Owned items modify owner and owned units only, never themselves

Internal Changes:

• AssemblyVersion includes build date in Major.Minor.Build.Revision:
  • Build equals the number of days since 1 January 2000 local time
  • Revision equals half the number of seconds since midnight local time
• Changed to ArgumentNullOrEmptyException where appropriate
• Changed NotImplementedException to abstract keyword where possible
• Reflowed all XML comments to a line width of 100 characters
• Source code lines may extend to 100 characters or more
• Renamed numerous classes to match new Scenario & World terminology
• Options:
  • Added suffix Options to all classes that manage user settings
  • Renamed class OptionsManager to ApplicationOptions

Version 3.2.1 (released 2005-03-06)

• Changed installer for binary package to Inno Setup
• Reordered class members to conform to MSDN sequence
• Removed RegexOptions.Compiled from Regex constructors

Version 3.2.0 (released 2005-02-28)

• Class Reference no longer lists .NET Framework internals
• Command-line and Drag & Drop arguments:
  • Added support for XML files with GZip compression
  • Improved handling of invalid binary files
  • Separate messages for missing and invalid files
  • Revised file search (see online help)

Hexkit Game:

• Added Hexkit Command Language (HCL) instructions
• Saved games are now GZip compressed via #ziplib
• Cannot keep playing after content invariant violation
• Fixed formatting of victory congratulations
• Debug menu: Added Show Command Counters dialog
• Map View: Re-enabled display of selected unit

Internal Changes:

• NotImplementedException thrown when override required
• Changed XmlName from override to reflection where possible
• Global: Added class Random for random number generation
• Global.Xml: Moved all path name fields to class Global.Path
• Players.AlgorithmGeneral: Removed obsolete property Random
• Scenario.Areas: Renamed PackMapContents to PackAreas
• Scenario.Classes: Added GetClass(String) overload
• Configuration: Added namespace Instruction
• Configuration.Document:
  • Added Contents hashtable containing all content objects
  • Renamed property MapContents to Hexagons
  • Renamed method GetMapHexagon to GetHexagon
• Configuration.UnitAgent: Ignores current unit locations
• Configuration.UnitBase:
  • Removed property setters that required overrides
  • Added virtual method CreateMoveEvent (called by Move)
  • CreateAttackEvent: May be overridden by rule script
  • FindMovePath: Added parameter for source hexagon
• Configuration.Command: (overview only, too many changes!)
  • Added support for HCL instructions (see CommandBase)
  • Added execution context (see CommandBase, ExecutionContext)
  • Added execution counters (see CommandBase, ExecutionCounters)
  • Simplified command queueing (see CommandBase, Executor)
  • Removed all ConstXmlName fields; XmlName returns type name
  • Removed support for obsolete random number storage
• Configuration.InvalidCommandException:
  • Changed base class to Exception, as per FxCop
  • Moved up from namespace Hexkit.Configuration.Command
  • Indicates invalid game commands or HCL instructions

Version 3.1.0 (released 2004-12-29)

• Class Reference now compiled with NDoc 1.3
• Greatly enhanced pathfinding section in Hexkit User’s Guide

Hexkit Game:

• Map view panel shows new express menu by default
• Game menu: Added Next Active Unit to cycle through units
• Command menu: Disband Units and Info: Unit Status: Added filters to show mobile or immobile units only

Internal Changes:

• Converted modal message dialogs to ControlBuilder format
• Revised prefix scheme of remaining global string resources
• Global.Controls: Added FindDialogTemplate and ShowDialog overloads
• Global.RM: Added internal method ShowTemplateLoadError
• Hexkit.Scenario.xsd:
  • Moved factions/faction/home to areas/factionLocations/home
  • Moved classes/unit/placeTarget to areas/unitClassLocations/place
• Scenario.Areas:
  • Public copy constructor shares data with specified instance
  • Added internal properties FactionLocations and UnitClassLocations
• Scenario.FactionSetup: Home returns Areas.FactionLocations[Id]
• Scenario.UnitClass: PlaceTargets returns Areas.UnitClassLocations[Id]
• Configuration.ContentBase: Added property IsPlaced
• Configuration.UnitAgent: Added new IPlanarAgent members
• Configuration.UnitBase:
  • IsActive now checks for IsPlaced as well as IsAlive
  • Added methods GetPartialOccupation and GetRelaxedRange
  • Replaced method CanPlace with CanOccupy
  • CanMakeStep now forwards to CanOccupy by default

Version 3.0.1 (released 2004-12-06)

• Reformatted WhatsNew file for clarity
• Replaced both mouse timers with Application.Idle event handlers
• Options.Replay: Added property Delay for millisecond delay

Hexkit Game:

• Queued commands are replayed at current Replay Speed
• Data View: Disabled alphabetic sorting of hexagon contents
• Map View: Temporarily disabled display of selected unit

Version 3.0.0 (released 2004-11-30)

• Added big scenario based on the Roman Empire
• Added river segments and more road segments to tileset
• Thoroughly revised Hexkit User’s Guide and added several new chapters
• Added progress updates during map creation and command replay
• Fixed terrain packing that was broken in the last release

Rules (default & script):

• Compiled scripts may be debugged with Visual Studio .NET
• Images may define connections to neighboring hexagons
• Increased maximum property range to ± 10,000,000
• Revised updating of faction resources (see Hexkit User’s Guide)
• Fixed unit & item modifiers to unit attributes
• Factions may define unit resources that can be resupplied
• Unit resource limit by initial value is now optional
• Unit default name indices are counted per faction

Search & Destroy algorithm:

• Fixed rounding errors in value-guided building
• Fixed & improved target selection (see Hexkit User’s Guide)
• May perform “suicide” attacks at the end of a turn
• Shows currently considered unit in status bar
• Withdraws units to resupply if necessary

Hexkit Game:

• Fixed crash when multiple units share initial hexagon
• Computer player message panel resizes automatically
• Property displays show decimal places according to scale
• Replay menu: Fixed display of total turn count
• Info menu: Show Factions: Fixed missing list view text

Hexkit Editor:

• Areas page: Changing hexagon owner updates map display
• Various dialogs:
  • Fixed property scale errors for negative values
  • Fixed redundant map view synchronization
  • Fixed and revised various list views and tab pages

Internal Changes:

• Micro-optimized array accesses and collection loops
• Default pathfinding parameters are now set in rule scripts
• Configuration:
  • Added enumeration RangeCategory
  • Removed unused delegate SelectValuableCallback
  • Simplified instantiation of ContentBase and derived classes
• Configuration.Command classes:
  • Merged ICommand and BaseEmpty into class CommandBase
  • Changed all command parameters to weak references
  • CommandEvent: Removed all faction/content parameters
• Configuration.Command.CommandEventType:
  • Message: Changed faction/content parameters to Name strings
  • Changed MoveContent/ShowContent to MoveImage/ShowImage
  • Replaced MoveUnits with Visible (see Class Reference)
• Configuration.Command.CommandBase:
  • Added Commands queue for automatic command execution
  • CreateEvents automatically set to false after command execution
  • Events collection is read-only if CreateEvents is false
• Configuration.ContentBase:
  • Added properties DisplayClass and Visible
  • Changed property DefaultName to proxy for ContentClass.Name
  • Added methods SetUniqueIdentifier and SetUniqueName
  • Removed non-standard CompareTo methods
  • Sealed various inherited members in derived classes
  • ApplyAttribute/ResourceModifiers: Restricted to UnitBase
  • SetHexagon/SetOwner: Fixed updating of unit attributes
• Configuration.Document:
  • Constructors start with garbage collection
  • Added method HaveBeginTurn (moved from Game.Session)
  • Removed proxy properties MapRectangle and Rules
• Configuration.FactionBase:
  • Added method Initialize for custom rule scripts
  • Added InstanceCount and AddInstance, as in Document
  • Added SupplyResources, GetSupplyTargets, SetSupplyResources
  • Integrated ResetResources with ApplyResourceModifiers
  • Removed unused properties MaxAttackRange and MaxMoveRange
  • AutoDisband: Fixed unwanted event creation
  • BeginTurn, EndTurn: Changed resource update sequence
  • Evaluate(ContentClass): Result adjusted by buildable unit classes
• Configuration.MapHexagon:
  • Added property SupplyResources
  • Added methods CountCombatUnits and CountMobileUnits
  • Added methods IsConnected and SetUnitOwner
  • Added Distance, SortByDistance, and nested class DistanceComparer
  • Removed non-standard CompareTo methods
  • Removed non-intuitive method HasAlienOwner
• Configuration.UnitAgent:
  • Added property Attacking for movement toward attack targets
  • Implemented new interface method IsNearTarget
• Configuration.UnitBase:
  • Added properties CombatStrength, IsCombat, and IsMobile
  • Restricted CanAttack and CanMove by IsCombat and IsMobile
  • Renamed property MaxMoveRange to MaxMoveCost
  • Added setters to properties MaxAttackRange and MaxMoveCost
  • Added method GetSupplyResources
  • Renamed GetAttackLosses to GetCombatLosses
  • Replaced GetAttackStrength with Utility.AddCombatStrength
  • De-virtualized GetAttackTargets and GetMoveTargets
  • Replaced GetMovePath with static FindMovePath
  • Replaced GetMaxAttackRange with Utility.GetMinMaxAttackRange
  • Replaced GetMaxMoveCost with Utility.GetMinMaxMoveCost
  • GetCombatLosses: Optionally ignores attacker locations
  • Move: Changed created events to Visible/MoveImage/Visible
• Editor.TabAreas: Added property Configuration for use by dialogs
• Game.Session: Removed method ComputerEndTurn (see MainForm)
• Game.Utility:
  • Changed ShowMapViewEvent to ShowImageEvent
  • Added method ShowVisibleEvent
• Graphics.MapViewClient:
  • Changed MoveContent/ShowContent to MoveImage/ShowImage
  • Removed method ShowUnits
• Graphics.MapViewPanel:
  • Changed ShowContent to ShowImage
  • Only shows content objects whose Visible flag is set
• Players.AlgorithmBase.FindBestConfiguration: Now issues BeginTurn
• Players.AlgorithmGeneral:
  • Added methods PerformAttack, PerformGroupAttack
  • Added methods SelectAttackTarget, SelectMoveTarget
• Players.SearchAndDestroy.FindBestConfiguration: Thoroughly revised
• Scenario: Added class ImageFrame with bounds and connections
• Scenario: Changed IScenarioElement to abstract class ScenarioElement
• Scenario.ClassImage: Renamed to ImageObject
• Scenario.ContentClass: Removed non-standard CompareTo methods
• Scenario.FactionSetup: Added property SupplyResources for unit supply
• Scenario.IValuable: Removed IComparable inheritance
• Scenario.Property: Added property DecimalPlaces for display formatting
• Scenario.Resource: Added property Limit for restricting unit resources
• Scenario.Rules:
  • Added appropriate compiler switches for debug/release mode
  • CompileScript: Rules assembly saved to disk file in debug mode

Version 2.9.3 (released 2004-08-08)

• Content objects may specify a fixed non-zero image frame
• Map view display now supports full alpha blending

Hexkit Game:

• Fixed crash after global defeat
• Data Panel: Disabled sorting for terrain contents
• Command menu: Move Units: Fixed arrow display
• Info menu: Content Classes: Added image frame browsing
• Info menu: Command History: Fixed initial scroll position
• Debug menu: Bitmap Catalogs: Fixed display if closed by user

Hexkit Editor: Fixed numerous image and reference bugs

Internal Changes:

• Documented, revised and restructured all XML schemas
• Configuration: Reduced default collection capacities to save memory
• Configuration.ContentBase:
  • Added properties FrameOffset and InstanceName
  • Added conversion method ToContentSetup
• Graphics.ImagePanel: Added property Frames and methods Clear, Show
• Graphics.ImageUtility: Changed outline arguments from Color to Pen
• Graphics.MapViewBase.DrawTileBitmap: Revised parameters and algorithm
• Scenario: All name strings are interned to save memory
• Scenario: Added class ContentSetup for content instances
• Scenario.Classes: Added method GetClass(ContentSetup)
• Scenario.ContentClass: Added properties FrameCount and FrameIndex

Version 2.9.2 (released 2004-07-12)

• Updated the readme.txt file for DeBray Bailey’s tileset
• Hexkit Game: Command menu: Fixed buttons in Place Units dialog
• Hexkit Editor: Areas page: Added flexible Change Map Bounds dialog

Internal Changes:

• Signed precompiled assemblies with a strong name
• Added CLSCompliant, ComVisible, and security attributes
• Removed assembly hash codes as they are no longer required
• Changed all user interface code to Control/MenuBuilder
• Changed delegate suffixes from Delegate to Callback
• Changed XML attribute for application “title” to “product”
• Eliminated all uses of ValidString structure
• Configuration:
  • Collections are read-only where possible
  • ContentBase: Added method MoveToTop
  • Document: Removed unused IDisposable interface
  • FactionBase: Split GetUnits into two parameterless methods
• Global.Collections: Moved all classes to Tektosyne library
• Graphics.MapViewClient.SelectContent: Renamed to ShowContent
• Options:
  • Added enumeration ComputerLevel for Computer.Default
  • Enumerations are serialized to symbolic constants
  • Document: Renamed to OptionsManager
• Players: Added ComputerMessageCallback for message display
• Scenario: Collections are read-only for Hexkit Game where possible
• Scenario.Document.Dispose: Correctly disposes of rule script

Version 2.9.1 (released 2004-05-14)

• Changed to InvalidEnumArgumentException where appropriate
• Window.FrameForm/FrameMenu: Changed to reflect new MenuTemplate

Version 2.9.0 (released 2004-05-09)

• Revised possession valuation model (see Hexkit User’s Guide)
• Changed and improved computer players (see Hexkit User’s Guide)
• Counter-attacks by default select random attacker in range
• Troll Chess: Halved gold bonus but increased income for Trolls

Hexkit Game:

• Added attack arrows to visualize attack direction(s)
• Added movement arrows to show exact movement path
• Info menu: Faction Ranking: Added Hexagon Values selection

Internal Changes:

• Added Configuration.Executor and Game.SessionExecutor classes
• Configuration.Command.BaseEmpty: Added overload NextRandom(Int32)
• Configuration.UnitBase: Added method CanPlace (similar to CanMakeStep)
• Configuration.UnitBase.GetMovePath: Changed to return IPlanarPath
• Graphics.MapViewClient: Added AttackArrows & MoveArrows properties
• Scenario: Added IValuable interface, implemented by all possessions

Version 2.8.9 (released 2004-04-19)

• Added automatic Begin Turn command for turn calculations
• Added custom placement locations to unit classes
• Added optional unit flags indicating owner, stack size, and status
• Added victory & defeat conditions and reset option to resources
• Rules: A defeated faction’s items appear on its home location
• Rules: Newly placed units cannot move or attack
• Search & Destroy: Fixed invalid moves and passive units
• Troll Chess: Added bonus healing and extra gold to Trolls

Hexkit Game:

• Added separate autosave file for computer players
• Fixed list view selections and data view crashes
• Fixed Place command to check for enemy units
• File commands stop replay and pause faction activation
• Game menu: Added Auto-Place Units for faster unit placement
• Game menu: Added Stop Computer to interrupt computer player
• Game menu: Player Setup allows instant player switching
• Replay menu: Added Turbo speed setting (no animations)
• Command menu: Added placement filter to Build Units dialog
• Info menu: Added Faction Ranking and revised other items

Hexkit Editor: Factions page: Revised Change Home Locations dialog

Internal Changes:

• All IXmlSerializable implementations are implicit
• Graphics.MapViewClient: Added CenterSelect method
• Graphics.MapViewClient: SelectedHexagon calls ScrollIntoView
• Graphics.MapViewPanel: Sped up drawing of GDI+ decoration
• Players.ComputerThread: Improved thread synchronization
• Scenario: All classes implement IScenarioElement implicitly
• Scenario: Moved Home locations from Areas to FactionSetup

Version 2.8.8 (released 2004-03-31)

• Added Search & Destroy algorithm for computer players
• Added custom movement and a road to Troll Chess scenario
• Added configurable display scale for properties
• Added passive Capture ability to terrain classes
• Moved “Info” pages from online help to new Hexkit User’s Guide

Hexkit Game:

• Revised dispatching to (local or remote) human players
• Fixed several errors regarding Build command
• Data View: Selecting a unit shows it in the map view
• Map View: Clicking on a unit stack cycles through it
• Replay menu: Fixed command errors and selection display
• Replay menu: Now somewhat smoother and more responsive

Internal Changes:

• Added application info element to all XML schemas
• Added assembly Hexkit.Players, removed Hexkit.Dialog
• Added assembly hash codes to detect modifications
• Configuration.Command.Attack/Move/Place: Check if (un)placed
• Configuration.Command.ICommand: Added Units property
• Configuration.Document: Added Clone method for deep copy
• Graphics.MapViewClient: Added method SelectContent

Version 2.8.7 (released 2004-02-25)

• Added sophisticated combat resolution mechanism
• Unit resources are restricted to their initial values
• Greatly enhanced Troll Chess scenario and custom rule script
• Adjusted layout for 640 x 480 desktop with Large fonts
• Cleared read-only attributes on files in binary package

Hexkit Game:

• Added event view panel for commands and event messages
• Added Replay menu to control interactive replay
• Command History dialog enhanced & moved to Info menu
• Fixed crash when picking up items
• Fixed display update after command execution
• Fixed victory message and loading of finished games
• Removed obsolete Game: Show Winners command
• Show Factions: Fixed crash when selecting modifier only

Hexkit Editor: Areas page:

• Fixed crash when class properties are missing
• Fixed display update after changing contents

Internal Changes:

• Configuration:
  • Added Document parameter to content creation methods
  • Moved content instance counting to Document class
• Configuration.Command: Execute methods no longer call Validate
• Configuration.Command.CommandEventType: Revised message events
• Configuration.Command.ICommand: Added properties Source and Target
• Configuration.UnitBase: Most virtual methods accept IContentBaseList
• Dialog.GameUtility: Moved to Game.Utility and revised methods
• Graphics.MapViewClient: Added method ScrollIntoView

Version 2.8.6 (released 2004-01-27)

• Hexkit is now distributed under the MIT license
• Added new variant of demo scenario, Troll Chess (custom)
• Owner of placed units may differ from hexagon owner
• Added or standardized unit abilities:
  • Attack and Move (already present)
  • Build (moved from faction to unit class)
  • Capture and Recover (unit class abilities)
• End Turn command:
  • Automatically disbands unsupported units
  • Fixed calculation of unit resources
• Relaxed several hexagon invariants due to above changes
• Fixed unit order and item painting on the map view

Hexkit Game:

• Fixed layout of dialog boxes with property lists
• Data View: Merged hexagon contents into a single list
• Attack Hexagon & Move Units: Fixed single-unit targeting
• Move Units: Implemented smooth unit movement

Internal Changes:

• Changed several dictionaries to simpler keyed collections
• Renamed Map properties to MapContents and MapRectangle
• Configuration.Command: Revised XML serialization
• Configuration.Command.BaseEmpty: Added random numbers
• Configuration.UnitBase.Disband: Moved to FactionBase
• Graphics: Added methods to show & move content objects
• Graphics.MapViewPanel: Revised many comments and methods
• Scenario.ContentClass: Revised XML serialization
• Scenario.Properties: Added several collection helper methods

Version 2.8.5 (released 2003-12-22)

• Unit resource modifiers are added rather than subtracted

Hexkit Game:

• Added commands Build Units and Disband Units
• End Turn command updates faction and unit resources
• Revised and enhanced Faction Information dialog

Internal Changes:

• Configuration.Command: Revised inheritance hierarchy
• Scenario: Added class CategorizedValue and collection classes

Version 2.8.4 (released 2003-11-28)

• Changed selected hexagon indicator to white hexagon frame
• Removed faction diplomacy and all related concepts
• Replaced Fantasy Demo Scenario with Troll Chess (default)
• Shortcuts for disabled menu items are properly disabled

Hexkit Game:

• Added commands Attack Hexagon, Move Units, and Resign
• Implemented default combat and movement rules
• Place Units command accepts overrides and multiple units

Hexkit Editor:

• Added option to delete all references when removing IDs
• Fixed another couple of bugs related to map editing
• Fixed null reference exception when removing factions

Internal Changes:

• Created specific XML names for all quantities
• Configuration: Changed protected Check… methods to Validate…
• Configuration: Revised command event notification
• Dialog: Consolidated all dialogs into a single assembly
• Graphics: Revised SelectedRegion handling
• Graphics.MapViewClient: Added MoveContent and ShowContent
• Graphics, Scenario: Used new Toolbox class HexagonRectangle
• Scenario.Areas.PackMap: Fixed packing of empty hexagons
• Scenario.FactionSetup: Allowed multiple contents of same class

Version 2.8.3 (released 2003-10-18)

• Moved version history to separate WhatsNew file

Hexkit Game:

• Added Place Units command and dialog
• Added Selection mode for target hexagon selection
• Changed ShowCommands dialog to show identifiers
• Saved games with invalid commands can be opened

Internal Changes:

• Configuration: Revised command management
• Configuration.FactionBase: Added proxy for Color property
• Configuration.MapHexagon: Added instance method ToString
• Global.RM: Added static methods ToString and ToHexagonString

Version 2.8.2 (released 2003-10-11)

• Added Show Owner option to View menus
• Reverted to old workaround for NumericUpDown edit bug

Hexkit Game:

• Added faction color code to Turn/Faction box
• Added Color and Home Location to Faction Status dialog
• Closing a session now properly disposes of scenario

Hexkit Editor:

• Added Change Faction Colors dialog to Factions page
• Added Change Home Locations dialog to Areas page
• Removed Factions page from Change Contents dialog
• Fixed exceptions when trying to change IDs
• Fixed inability to remove last remaining faction
• Fixed validation bug concerning Factions section
• Fixed several bugs related to hexagon ownership

Internal Changes:

• Adopted saner naming convention for event handlers
• Fixed initialization order for static strings
• Added faction color codes to Factions section
• Moved faction home locations to Areas section, added validation
• Graphics.MapViewPanel: Buffer cleared to control background

Version 2.8.1 (released 2003-09-23)

• Finally added Game Concepts section to Help file
• Added start menu shortcuts to installation process
• Revised entire property model (see Game Concepts for details)

Hexkit Game:

• Added default victory and defeat conditions
• Added default file name to File: Save menu command
• Added Show Winners command to Game menu
• Change Players: Improved e-mail address verification

Internal Changes:

• Added build script for NAnt 0.8.3
• Applied singleton pattern to several classes as appropriate
• Changed empty string comparisons to zero length tests, as per FxCop 1.21
• Structured all source files with #region directives
• Configuration: Added GameOver flag to control broadcast of finished games

Version 2.8.0 (released 2003-07-22)

Hexkit Game:

• Added turn progression and PBEM handling
• Reorganized main menu to cover added functions
• Added Default Computer settings to Game menu
• Added Command menu with End Turn command
• Added Command History dialog to Debug menu
• Added Turn/Faction counter with End Turn button
• Automatically save current game on End Turn command
• Center on faction home location at start of turn
• Fixed crash when loading saved games

Hexkit Editor: Added Factions page to Change Contents dialog

Internal Changes:

• Changed ApplicationException to specific system exceptions
• Added documentation for all exceptions that were changed
• Added faction home locations to Factions section
• Configuration: Added turn count and history of End Turn commands
• Configuration.Faction: Renamed FactionSetup to Setup
• Options: Added Game class with default computer player setting

Version 2.7.8 (released 2003-06-13)

• Added explicit Help buttons back to all dialogs
• Hexkit Editor: Fixed default background bug related to content changes
• Added error checking to mail/web access via Process.Start
• Added strongly-typed collections created by CodeSmith
• Configuration: Renamed Faction to FactionBase and Content to ContentBase
• Scenario: Renamed Stance to StanceSetup to avoid name clashes

Version 2.7.7 (released 2003-05-24)

• Hexkit Game: Added Unit Status dialog
• Hexkit Game: Removed Resource list from Faction Status: General dialog
• Hexkit Editor: Added Contents page to Change Faction dialog
• Configuration.Document: Added ActiveFaction property
• Graphics.MapViewClient: Renamed Highlight property to SelectedHexagon
• Graphics.MapViewClient: Added SelectedHexagonChanged event

Version 2.7.6 (released 2003-05-17)

• Added Item category back as a faction-only asset
• Added Unit and Item collections to scenario faction definitions
• Hexkit Game: Added current property values to Selected Hexagon box
• Hexkit Game: Added item inventory to Faction Status dialog

Internal Changes:

• Deleted HintPath assembly references to .NET Framework 1.0
• Removed most BeginUpdate/EndUpdate calls to avoid Windows.Forms bug
• Configuration.Content: Added DefaultName and removed IsNamed
• Configuration.Content: Added GetInstanceCount and revised InstanceCount
• Configuration.Content: Added Modified versions of all content property lists
• Configuration.Content: Created derived classes for all content categories
• Scenario: Moved static methods to their proper classes

Version 2.7.5 (released 2003-05-11)

• Added support for C#, VB.NET, and precompiled rule scripts
• Removed Item category which doesn’t fit the current design
• Renamed “Graphics” folder to “Images” to match section name
• Revised “Simple MAPI” section in ReadMe file

Hexkit Game:

• Added Game menu to manipulate the game configuration
• Added Player Setup and Change E-mail dialogs
• Enhanced Content Classes and Faction Status dialogs
• Revised Scenario Information dialog

Internal Changes:

• Project moved to .NET Framework 1.1 and Visual Studio .NET 2003
• All ReadXml methods now check for empty elements
• Added Hexkit.Help to solution as a Makefile project
• Configuration: Added classes for player management
• Configuration: Scenario hash code written as attribute
• Graphics.MapViewPanel.Dispose: Corrected implementation
• Options: Added missing XML representation comments
• Scenario: Added StanceCategory with supporting Stance methods
• Scenario.Document: Fixed embarrassing Scenario.Start.xml bug

Version 2.7.0 (released 2003-04-04)

• Options are now saved to schema-validated XML files
• Configuration and Options files stored in user-specific folders
• Check for write permission at startup and fail gracefully
• Fixed map view zooming & scrolling, documented IntelliPoint issues
• Revised Help introduction, eliminated empty sections

Hexkit Game:

• Added “Save Window” command to View menu
• Renamed menu Display to View for standard conformance

Hexkit Editor:

• Added View menu to manipulate map view on Areas page
• Fixed background terrain bugs in Change Contents dialog
• Updates progress bar when loading a Scenario section

Internal Changes:

• Added .NET application configuration files
• Adopted Toolbox types added in versions 1.7.0 through 1.8.2
• Completely revised terminology, XML comments, and coding style
• Graphics & Options: Added unique identifiers to map views
• Graphics.MapViewClient: Added instance method CenterOn
• Graphics.MapViewClient: Changed Scale property to integer percentage
• Graphics.MapViewServer: Added instance method CloseClient
• Scenario: Added category enumerations for ContentClass and Property

Version 2.6.0 (released 2003-02-24)

• Changed ReadMe file to HTML format
• Added scenario and configuration attachments to error e-mail

Hexkit Game:

• Added option to toggle hexagon grid outline
• Added command to save current map as Areas XML file

Hexkit Editor:

• Added page for Areas section
• Fixed bug preventing processing of inlined subsections
• Fixed crash bug when class used nonexistent class image
• Improved workaround for NumericUpDown edit bug
• Improved category handling for properties and classes

Internal Changes:

• Added separate class reference compiled by NDoc
• Converted all HTML Help pages to UTF-8 encoding
• Changed all XML parsing from XmlDocument to XmlReader
• Started to revise and enhance all XML comments
• Graphics.MapPanel: Can receive focus for scroll wheel messages
• Graphics.MapPanel: Fixed transparency issues with grid and scaling
• Scenario: Include comments no longer set section file paths
• Scenario: Allowed repeated identifiers in image and content stacks
• Scenario: Changed element name “bounds” to “rectangle”
• Scenario: Revised categorization of ContentClass and Property
• Scenario: Revised XML parsing and validation of scenario elements
• Scenario.Areas: Changed content naming mechanism
• Scenario.Areas: Removed unnecessary border color element

Version 2.5.0 (released 2002-12-12)

Hexkit Editor:

• Added page for Factions section
• Added option to globally change identifiers

Internal Changes:

• Configuration.Content: Added unique IDs and invariants
• Configuration.Faction: Added “Current Resources” collection
• Scenario.Rules: Revised script design, added faction factory

Version 2.4.0 (released 2002-11-25)

• Replaced “Help” buttons with fashionable “?” buttons

Hexkit Editor:

• Added pages for Properties and Classes
• Added tooltips to symbolic dialog buttons
• Background image property shown correctly
• Worked around edit bug of NumericUpDown control

Internal Changes:

• Scenario: Added Properties section
• Scenario.Rules: Added standard Initialize method
• Scenario.Classes: Added optional property attribute
• Scenario.Factions: Added optional property attribute
• Scenario.Factions: Added “buildable” attribute to units

Version 2.3.1 (released 2002-10-17)

Hexkit Editor:

• Added buttons to re-order animation frames
• Fixed “Add Entry” selection and crash bug

Version 2.3.0 (released 2002-10-14)

• Added scenario file editor to distribution
• Display automatically adapts to Windows font size
• Scenarios load per drag & drop or command line
• Replaced faction alliances with numerical stances

Hexkit Game:

• Saved games store relative scenario paths
• Saved games store MD5 checksum for scenarios
• Saved games load per drag & drop or command line

Version 2.2.1 (released 2002-06-10)

• Game: Mouse wheel can be used to change zoom levels
• Code changes for better .NET style conformance

Version 2.2.0 (released 2002-06-04)

• Hexkit Game: Save Game creates schema-validated XML files
• Hexkit Game: Debug Scenario creates valid scenario XML files
• Revised and enhanced custom XML file inclusion

Version 2.1.0 (released 2002-05-27)

• Source code rewritten in C# for the .NET Framework
• Scenario-specific rule scripts via JScript .NET source files
• All external text and XML files in UTF-8 format
• All scenario text now exposed through dialog boxes
• Unnecessary registry access removed again

Version 2.0.1 (released 2002-02-20)

• (Updates to obsolete C++ code only)

Version 2.0.0 (released 2002-02-18)

• Sources rewritten in C++, available as ZIP archive
• Self-installing binary distributions for Windows 9x and NT
• Internal text Unicode only, external ANSI or UTF-16
• Scenario data read from XML files using MSXML 2.5
• Image data read from PNG files using libpng/zlib
• Included free fantasy tileset by DeBray Bailey
• Added automatic e-mail error reporting system
• Added help file, saving/loading, registry access

The fateful day of 2001-12-30

• Permission obtained to use DeBray Bailey’s tileset
• Work on expanded Hexkit in C++ started

Version 1.2.1 (released 2000-12-02)

• Package unchanged except for compilation options

Version 1.2.0 (released 2000-04-16)

• Entire package changed to support child windows
• Work on Hexkit ceased due to lack of perspective

Version 1.1.0 (released 2000-04-04)

• (Updates to obsolete C code only)

Version 1.0.0 (released 2000-03-26)

• Initial release (C code with “programmer art”)