Jesse Bollinger – Page 3 – Jesse Bollinger

Game Dev Tip #4: Breathe life into your game with custom shaders and special effects

The standard approach to texturing most objects in most games tends to be to just assign each object to use some combination of diffuse coloring, specularity, normal mapping, transparency, and emission. More advanced physically-based shading techniques are also sometimes used, depending on the needs of each project.

This is all well and good of course, and works fine for many use cases, but sometimes it can get a bit stale. There are a lot more fun and imaginative things that you can do with shaders than just these standard use cases. A shader will let you express any arbitrary visual effect you want. You just need to know how to communicate your intent properly. If you can dream it, you can shade it, pretty much.

Game Dev Tip #3: Make your game immortal using the power of PCG and random generation

Game designers like to think of their worlds as being like living virtual worlds that people can escape to. This is an appealing sentiment, but unfortunately most games don’t really qualify as living virtual worlds. One of the most important reasons why they don’t is because most games can only be experienced once, after which re-experiencing the game immediately becomes mostly an exercise in redundancy. A real living world wouldn’t be like that.

However, it doesn’t have to be this way. A game can be made to be infinitely long and to create a new experience every time it is played. How long the game remains fun after that depends upon the strength of the core gameplay mechanics, but nonetheless the length and surface-level variation of the game can be extended to infinity relatively easily.

Game Dev Tip #2: Good art means so much more than just graphical fidelity

The pursuit of graphical fidelity, render quality, and advanced graphics engine features is often very appealing and difficult to resist, but it can also be a siren’s call. It is often a complete waste of valuable time and resources past a certain point. What the best level of graphical fidelity is depends on each specific game of course, but many game developers fall into the trap of thinking they need far more graphical fidelity than they actually do.

Obsession with raw technical graphical fidelity also has a tendency to distract many game artists from what actually matters the most: the quality and stylistic personality of the art itself. A game with a great art style but a relatively weak graphics engine will almost always be better than a game with a great graphics engine but a terrible art style. Art style and thematic personality are almost always more important than raw graphics tech is.

Game Dev Tip #1: How to make changes to gameplay without screwing up existing balance

Most game designers tend to just modify the parameters of the entities (the objects, items, creatures, abilities, etc) of their games arbitrarily, in an undisciplined way. They just freely change each parameter however they want, and believe (falsely) that the only part of the game’s balance that will consequentially change is the specific thing they modified.

However, this is actually not a safe way of making changes if you care about preserving a game’s carefully calibrated pre-existing balance. Many changes have unexpected effects. It is a common experience among game designers that after making a bunch of seemingly simple changes the balance of the game seems to have shifted in a frustratingly unpredictable way. Luckily though, there is an easy way to often greatly reduce this effect.

An expressive system for specifying constraints in code makes reasoning about software much easier.

Hello. Since this website is only a day or two old at this point, there is probably nobody (or almost nobody) reading it so far. However, be that as it may, I want to at least put some form of real content up now, even if it is of little significance, so that I can start to get a bit of momentum going and so that the site will no longer be totally useless. As such, on a whim, I have decided to make this post here (the 2nd post ever) about some of my personal thoughts on the importance of being able to express constraints in an effective way when doing computer programming.

Despite how obvious one might think this point is, I think the point is still worth saying here. I find that it is actually surprisingly common for many popular programming languages and related tools to have unnecessarily weak or arbitrarily limited constraint specification systems. There is also likewise a surprising abundance of programmers who don’t seem to really grasp the usefulness of an expressive constraint system either.

I’ve decided to bring back my personal website, but different this time.

A while ago, perhaps a year or two ago, I used to have a personal website under this same web domain name, which was active for a few years, but it fell into disuse for a long time. I think the original version of the website first came into existence sometime around 2013 or 2014, shortly after I graduated college, but it has been a while since then so I’m not sure anymore. Eventually though, I decided to cancel and delete that version of the website to save a bit of money because it wasn’t actually being used for anything much at the time.

The old version of my website was used to host my resume, some examples of work I’d done, and various other miscellaneous things. I also had a few blog posts I made talking about a few random thoughts that interested me, mainly related to computer programming and game development and such. Additionally, I had a few miscellaneous tools and documents I made available to the general public that a few people found useful (e.g. a random music note generator for note name memorization practice).