— This upcoming video may not be available to view yet.
Since becoming open source, it has become possible to find out potential upcoming features in Xamarin Forms by just poking around the active branches in the repository (macOS support was visible in the repo before any announcement).
One of them is lv2spike. From just reading the commit messages, it seems this is a new CollectionView, based on UICollectionView for iOS and RecyclerView for Android. This is something that has been needed for a while, but is a big enough undertaking that I understand why it has taken a while. After all the branch suggests this is still just a spike. There are quite a lot of feature requests for the Xamarin Forms ListView that are just not possible (like this one for horizontal layout) mainly because the iOS implementation is based on UITableView.
This will open lots of possibilities. My biggest concern is that despite the push forward with features, Xamarin Forms is accruing bugs even faster, and with the expanded platform support this could just get worse.
— This upcoming video may not be available to view yet.
I win
Tic-tac-toe Collection is now available on Android on the Play Store. Additionally, I’ve started a new blog to host random content about the game (initially just release notes, but I actually keep thinking of interesting things to write).
— This upcoming video may not be available to view yet.
For various reasons I decided to write a Tic Tac Toe game in Xamarin Forms. At the moment it supports variable board sizes, variable win line size (so it implicitly supports Gomoku) and a few custom rules like misère, a pie rule and disallowed overlines.
It currently functions on Android, iOS and Windows, but is only released on Android for now.
Apart from experimenting with various features of Xamarin Forms (as well as managing Nuget packages), my goal is to try and add all the options. Features I’m planning:
— This upcoming video may not be available to view yet.
When writing XAML for Xamarin Forms, you may across the error: Unable to cast object of type 'Xamarin.Forms.Xaml.ElementNode' to type 'Xamarin.Forms.Xaml.ValueNode' This is nearly always caused by assigning a value to an event in XAML, instead of specifying a method name. A common example is: <Switch Toggled="{Binding IsToggled}" />Toggled is the name of an event. The property that was probably intended is called IsToggled. <Switch IsToggled="{Binding IsToggled}" />
Your goal is to assemble meals out of various ingredients, cook them, and serve them. Over time the meals get a bit more complicated and the levels get a lot more complicated. It is strongly designed to be played cooperatively with up to four people, and even supports two players on a single controller.
My only complaint would be the difficulty is based too much on complicated level design (and jumps up a bit too quickly). Some times the controls are not exactly tight and you can end up selecting the wrong thing - having levels with moving targets or slippery floors for instance just accentuates an otherwise minor problem. I would have preferred more meal variations (that are also more complicated) on simpler levels.
But despite all that it’s a fun party game that almost anyone can play. And of course it is made in Unity.
One final note. The first video in the playlist above was generated by Google Photos. It turned out well, except for its automatic cropping.
— This upcoming video may not be available to view yet.
After finding YouTube doesn’t support moving videos between channels, I figured I should try to organize things properly sooner rather than later. Also, here is a brand new freshly recorded video of the original Gravitas on Xbox 360.
— This upcoming video may not be available to view yet.
Unity has a pretty cool feature called “gizmos”, that are things rendered only in the scene view of the Unity editor. Many built in game object types render a gizmo of some sort, but you can freely add your own. This can be very useful for debugging.
This is a visualization of the gravity (more precisely it’s the low resolution grid of gravity mentioned in the previous post).
The direction of the line is the direction of the gravity, and the length is the strength.
The most important feature in Gravitas is clearly the gravity, so getting it right is crucial. One important principal to be aware of when making games though is that “right” doesn’t necessarily mean “technically perfect” or “scientifically accurate”. “Feeling right” and being fun to play with is often more important. Despite that, the gravity in Gravitas is essentially correct. By correct, I mean a numerical approximation of Newton’s law of universal gravitation. The formula for calculating the gravitational force between two masses is:
Gravitation
where:
F is the force between the masses;
G is the gravitational constant (6.674×10−11 N · (m/kg)2);
_m_1 is the first mass;
_m_2 is the second mass;
r is the distance between the centers of the masses.
For simplicity and performance reasons, there are a few things to be aware of though. Firstly, I decided not to worry about real world units since the planets, ships and torpedoes are not realistically scaled to each other (either by size, mass or distance from each other). This means I can decide that my torpedoes have a mass of 1, thereby eliminating a multiplication for the most common case. This also means I can choose the value of G to be whatever looks or feels right.
This is still quite a significant calculation that has to be performed every frame for every torpedo/planet pair.
As it turns out though, the maximum number of torpedo/planet pairs is quite low. Based on the limits of the previous version of Gravitas, there were at most 9 ships, firing at most 3 torpedoes, with at most 11 planets. This means 9 × 3 × 11 = 297 times to calculate the strength of the gravity each frame. In practice I don’t think I ever saw so that many torpedoes (every ship using a triple-shot special power at once).
But then I wanted to add dust. By dust, I mean a trail from the torpedoes, that is also affected by gravity. At a minimum this should generate one particle per frame and be at least a couple of seconds long at normal torpedo speed. This means each torpedo could easily have a hundred dust particles all needing the same gravity calculation. All of a sudden there could be 300,000 gravitation calculations per frame. On my laptop it ran fine. On my phone, not so much.
There are a number of possible ways of solving this issue, but the one I settled on is based on the principle that accuracy of simulation of the dust particles (as opposed to the torpedoes) is not so important. That is, if the dust particles don’t behave perfectly, it doesn’t really matter. One thing to notice about the gravity is that the only dynamic data it depends on is the position of the dust. The mass of the dust is fixed, and the position and mass of the planets are fixed (at least per round).
My solution was to pre-calculate the strength of gravity on a dust particle for all the positions in a low-resolution grid. This means I can “calculate” the gravity by doing a relatively cheap lookup.
— This upcoming video may not be available to view yet.
TLDR: When setting the Triggers property in XAML, use the actual type of the parent tag, not a supertype.
After recently updating Xamarin Forms from 2.3.2.127 to 2.3.3.175, I started getting an InvalidOperationException: The BindableProperty "Triggers is readonly" inside InitializeComponent. Unlike many problems, this was quite easy to track down. InitializeComponent errors are generally XAML, and in the page in question there was a single Trigger. In this case the solution was simple. The Trigger was on a custom Button type, but I was setting it specifically using Button.Triggers. Changing it to be the actual type fixed it. So, I changed it from
Gravitas is rapidly approaching something playable, now that ships can be destroyed and new levels are generated.
“Something playable” is still quite far away from being an actual game. In terms of features required for even an alpha release, it still needs: scoring, match state, player lobby, AI, and better level generation.
Some other features I would rather have but aren’t strictly required include: special powers (especially warping, to get players out of impossible situations), better UI feedback for touch controls (which was not necessary for the original) and some match options.
