BoardBuilder is a factory class used for creating Board model for the Farout game. In following I will briefly go through the design of the BoardBuilder and give you reasoning behind my decisions. In my next post I will go in more detail by showing you some source code and hopefully I have a working example as well.
By creating dedicated builder class we separate construction role from the model role that the Board class represents. It also keeps Board class simpler and makes it possible to change construction process without a need to touch Board’s implementation.
During the construction we have to allocate memory blocks which are no longer needed when construction has finished. By keeping those allocations in builder only it is easier for us to control how memory is used and when it is freed.
Construction process is divided into small simple steps to make source code easier to understand and maintain. As a rule of thumb every function has only one purpose and if I see copy paste code anywhere I will move that code into own function. I prefer a lot of small methods to few monolithic ones, therefore my classes usually have quite long definition.
Below is the static model of the BoardBuilder and after that you can find description of each class and their purpose.
Vertex represents single point in 2-dimensional world. It has x and y value defined as floating point numbers.
Segment represents one line segment that is constructed of two or more Vertices. Vertices are referenced by the Segments. Therefore same Vertex can be used in several Segments.
Hexagon represents one hexagon and is constructed of exactly six Segments. Neigbouring Hexagons share one segment with each other. Segments are referenced by the Hexagon instances, that way we can modify Segment and modifications are instantly visible in every Hexagon referencing the modified Segment.
Region is a tile that is constructed from one or more Hexagons. Region is defined as generic class and the unqualified type parameter is used for referencing the actual region data. Regions own instance of java.awt.Polygon that defines their shape. Polygon class is created because it can be used as a tool for several tasks. E.g.
To check if certain point is located inside Region (e.g. region.shape().contains(x, y)).
To mask (clip) textured blitting (e.g. graphics.setClip(region.shape())).
To draw region borders (e.g. graphics.drawPolygon(region.shape())).
To get maximum bounds of the Region (e.g. region.shape().getBounds()).
Board construction is handled by the BoardBuilder class. Construction parameters are given in a BoardBuilderParameters class. Construction happens in following order.
Hexagonal Vertices are constructed
Segments are constructed by connecting proper Vertices
Hexagons are constructed by collecting proper Segments from all Segments
Hexagons are dehexified as described in earlier post
Regions are constructed from Hexagons by combining selected neighbour Hexagons, adjacency is validated when new Hexagon is added to a Region and if the added Hexagon is valid all, except the connecting Segment, are added to the Region
Shape is constructed for each Region
Board is created and ownership of the created Regions is transferred to the Board
Created Board instance is returned to the caller and is ready to be used
In my search for a solution to make my graphics scalable I heard a rumor about Nintendo having released their pixels-to-vector algorithm as open source! Could this be true? I haven’t found any reliable information of this yet.
What I am talking about is something like Johannes Kopf and Dani Lischinski had developed and described in their paper Depixelizing Pixel Art. Sadly, their solution is not available for public and it seems that I end up looking this paper after every search attempt… There is something going on at the SNES scene, for example xBr 2.2, but real time shaders aren’t exactly what am looking for.
Hexagon has appealing characteristics for a map tile. It has six neighbours and the distance from any hexagon to its neighbour is exactly same. More traditional square based map tile has eight neighbours and distance varies from 1 to 1.414.., depending on in which direction particular neighbour is located at. However, they both have one characteristic in common, they look dull.
If you take a closer look at Small World map you will see that map tiles have hexagonal aspect and they do not look dull. Tiles have pretty strong border in high contrast which separates tiles from each other. Hexagon segments have been deformed and the tiles are textured using hand drawn textures with some extra details on top of them. These little finishing touches make them look great and pretty hard to spot hexagon aspect when you look at the map.
As a part of Farout project I have been playing around with Dehexifying algorithm to make hexagon map looks something like Small World map in the image above. Algorithm is simple, yet the results are quite stunning. Algorithm can be divided into following steps:
Create vertices for hexagon map (in my implementation caller gives number of hexagons in horizontal and vertical direction, and width of one hexagon as parameters)
Connect vertices into segments, every segment contains exactly two vertices at this point (segments reference to vertices, therefore altering one vertex affects every other segment using same vertex)
Create hexagons from segments (hexagons reference segments, therefore modifying one segment alters other hexagons using same segment)
Deform the vertices (this could be done before step 3 it just happens to be 4th step in my implementation)
Split segments into several vertices. Number of vertices created for segment depends on the segment’s length after step 4. The longer the segment is the more vertices will be created.
Deform newly created vertices to make segments non planar.
After these six steps hexagon map looks surprisingly lot like a Small World map, depending on how well your deforming algorithms work. One has to remember that this is just a model for the dehexified map – what it really looks like depends on rendering algorithm, which I will talk more about in my next post.
It’s been a while.. Me and my friend Juha have been brainstroming ideas for a new multiplayer strategy game. We are both fans of Small World, really great board game from Days of Wonder. It is the game we play during our biannual meetings (warning: Finnish pages) and we even have a competition based on this game.
Therefore it is no surprise we have taken some ideas from the game that we are so fond of. Some of the rules are from a game concept we designed like almost ten years ago, but then forgotten because of other interests in life. We both felt that now is a perfect time to start a new project called Farout.
Farout is a game of conquer, diplomacy and economics. Who earns the most victory points wins. There are several different ways to earn victory points and most of them require use of army. Rules are still work in progress and the development will not start until we are both content with the rules.
All kind of information about Games and Game programming