I will probably not be making another post on this blog until February. If you have any questions or comments, feel free to contact me here or on twitter.

I made a video for the recent work I have been doing on the gameplay for Seabird.

Most of my work recently has been on designing how the wind in the scene should behave. The player is only able to keep from falling if they ride on a wind gust, or if another bird is holding onto them. In the video when the player is being held up by another bird, a red line drawn between the two birds.

In the storm there are also special wind gusts which will sometimes lead the player to a group of birds who may be willing to help. In the video these gusts are colored red.

For the past few months I have been experimenting with different ideas for the game mechanics. The game involves the player trying to stay with other birds. Gusts of wind from storms which pass through the scene threaten to separate the player from the other birds.

I think I may be 40% done with the work I am going to do on the gameplay. The current design seems to work well, and is enjoyable to play (as least to me). I plan to make a video near the end of September showing some of the new gameplay and artwork.

Recently I made a system for determining how the wind paths in the game will be placed within a scene.

Wind paths are the air currents or gusts that the player will need to navigate through to stay with other characters.

Due to the nature of how I plan to use these paths in the game, it is necessary that the layout for each wind path is chosen dynamically depending on what is happening in the game.

One approach I have found useful for creating the layout is to generate a chain of circles in which each circle is touching another circle's perimeter. A number of points are then chosen consecutively along the perimeter of the circle chain to describe the curved path. Straight line segments can also be part of the chain to provide variation in the path.

One of the benefits of this approach is that the circles and line segments that define the chain can be used as geometric primitives for overlap testing. This is necessary for determining if one path is overlapping another path.

Introduction to Series This is the fourth part in a series about programming with splines. Part 1: Introduction, Part 2: Closest Point, and Part 3: Arc Length can be found at those links.

Introduction to Post The gist of what I will be explaining today is the problem of inconsistent speed when moving down a spline. This happens when the spline’s control points are at different arc lengths from each other. This can occur when the control points have been specified by a person using a game’s level editor, or the control points are from a path imported from a digital content creation tool. I will show an approach to this problem I learned from a paper titled “Arc-Length Parameterized Spline

Introduction In this post I will give an overview of how I arrived at the current movement system for Seabird and some of the challenges that I faced. I will show the problems with my initial idea of using a vector grid, and how my use of cubic splines largely replaced that. Then I will discuss the reasons for going back to a vector-based approach, and the flexibility that it has given me for scene layout.

This video shows what the character and wind movement presently looks like:

<bad video URL> (Note: This scene is made of placeholder art. The player is marked by a circle.)

Requirements for a Movement System Most of the gameplay in Seabird involves trying to avoid becoming separated from other birds in scenes made up of wind currents. If the player loses sight of a bird, they may need to find another bird that is willing to help them.

The only gameplay requirement for the wind currents is that they present some

Introduction to Series This is the 3rd post on splines in a series I am writing primarily for game programmers and others interested in the basics of using splines in their software. In part 1 of this series I wrote an introduction to cubic splines. In part 2 I showed one way for how to find the closest point on a spline path to another point in the world.

Introduction to Post Today I will discuss the problem of finding the length of a spline. I will go into why it is useful and a little bit of the mathematics behind it. Afterwards I have some example code for an approach to finding the arc length. I also briefly discuss other approaches that may improve the accuracy of computing the length.

What is the Arc Length? When people discuss length in the context of a spline, th

This is the second part in a series on using splines for computer games and other real time applications. In this post we will briefly go over how we define the closest point and why we want to find it. Then we will more formally state the problem we are trying to solve. There is a short overview of numerical analysis and an approach called Newton’s method, and I will explain some of the problems with the method as well as a few ways to get around those problems.

(Note: if you are familiar with numerical analysis, skip to the "2 Strategies for Initial Guess" section.)

How to Think About the Closest Point on a Spline One way to think about the problem of finding the closest point on the spline is to imagine that the spline represents a road. We are trying to find the place along the road where the distance from the road to another object on the landscape (let’s say a windmill) is as small as possible. The road may twist back and forth many times. It could approach clos

This post is the first in a 4 part series about using splines in real-time applications, such as computer games. Part 2: Closest Point, Part 3: Arc Length, and Part 4: Speed Control can be found at those links.

The emphasis of this discussion is on making splines useful, specifically useful for real-time applications, where update time is critical, and getting stuck in update loops is a big no-no. Splines are a tool that many developers are familiar with, but there is some quirkiness to dealing with splines in practice.

In this first article I will give a short introduction to splines and their usefulness for the wind currents in Seabird. I will also show how to get the slope and sharpness of the spline c

I hope to have something to show by the end of August. If you have any questions or comments, feel free to contact me here or on twitter.

I will show in this article why game programmers should be aware of High DPI monitors and the way that operating systems such as Windows work with them. I will show the quality increase you can get by making your application High DPI aware on a platform that supports desktop scaling, as well as the problems with text rendering that show up when the operating system scales non-aware applications. I have written about how this came to my attention, as well as some background on High DPI displays and things to think about when programming to support them. At the bottom of this article is the minimum source code needed to enable High DPI awareness when using the SDL library on Windows.

(It is easier to see the difference if you open the image in a new window to avoid the page f

Ideas for a project change, sometimes substantially through the course of development. These are the current ideas and direction for Seabird.

What is the game about? Seabird is a game where you play as a bird that is having trouble flying. The goal is to find your flock, who are looking for you.

Gameplay: Seabird is a rogue-like game as far as procedural generation and permanent death of the player-character. The rest of the gameplay is different than other rogue-like games. It involves trying to find your way back to your flock by navigating through the environment and learning the behavior of the other birds that might be able to help you find your flock again. If you are not able to learn to work with the other birds, you will eventually fall into the ocean below.

World: Instead of a dungeon or a castle, Seabird takes place in the air. The game takes place in a 2D side-view environment. There are wind currents, gusts, vortexes, and all sorts of other wind formations. In

This is the first blog post for Seabird, a game I am designing based on character interaction. Seabird is the project that is keeping me busy through my college years. I am excited to have Seabird here on the handmade network.

I feel that the handmade network is a good place for this project for at least two reasons:

1. I have found the people here helpful and supportive, and I think this community will be valuable to help Seabird come together.
2. I care about learning how things work. This has influenced the choices of technology in the game which makes it fits nicely with the other projects here.

I started working on Seabird in 2016. Seabird started as a simple prototype. In the prototype there were a number of squares that would stay near other squares of their same color on the screen. The player controlled a square that was falling. If the player was near other squares, then the player would stop falling, but the other squares do not always want the player near them.