Programbling

1. Just Do It You don't need any special skills, training, experience, or endorsements to be a game developer. You don't need permission. You are a game developer when you start making games. You can make games right now! Make word games or observational games to play in the car.

Here are some of my current opinions on good game design practices: 1. Find the fun first - make sure the core game mechanic is fun before designing too much on top of it. If it's not something that's been done before then it's important to prototype and playtest early.

I've been thinking about trying my hand at 3D modeling to create prerendered game graphics. While reading through the usual "Which is better: 3DS Max, Maya, or Blender?" articles I found a few mentions of The Foundry's "MODO" and am becoming more and more convinced it's probably the way to

Character encoding is tricky these days, particularly from a language design and API standpoint. In the early days of computing, the 128-value ASCII Table was all you needed to work with, meaning that a string could just be composed of bytes and you'd be done. The original Unicode proposal defined

Just for fun I programmed up a Rogue solver for Pizza Hut's Pi Day contest "Option A": http://blog.pizzahut.com/flavor-news/national-pi-day-math-contest-problems-are-here-2/ # Pizza.rogue local digits = (0..9)->Int32[] local permutation = Int32[] forEach (p in 0..digits.permutation_count-1) digits.permutation( p, permutation ) contingent necessary (permutation[0] != 0)

At AdColony we eventually standardized on the following version numbering system for software releases. I'm quite happy with it and it's working out well: Codebase.Feature.Bugfix[.ReleaseCandidate] The most notable feature is that the true version number has four parts but we drop the fourth part for public-facing marketing

One thing that's been missing in Slag/Bard/Rogue over the years is an equivalent to the decision operator AKA ternary operator, e.g. // C++ printf( "The switch is %s.\n", setting ? "ON" : "OFF" ); Today I finally added something comparable to Rogue. It's called the select operator and in its

When I wrote my first version of this a few days ago I realized that Rogue's inline C++ support was not adequate for working with template types in C++ - there was no way to obtain the C++ name of a Rogue type for templating purposes. I added a few

The new Rogue Plasmacore I'm working on has 2D and 3D capabilities. The 3D will be typical 3D in many ways but the 2D is something a little different. It's important to me that the 2D graphics be as easy and straightforward to work with and think through as always

A consequence of a conversation I was having tonight, here's a brief code sample that demonstrates wrapping the C++ vector class in a Rogue class: VectorWrapper.rogue #================================================================== # VectorWrapper.rogue # # February 29, 2016 by Abe Pralle # # Compile with RogueC v1.0.2+ from # https://github.com/AbePralle/Rogue # # roguec VectorWrapper.rogue

I finally got around to reimplementing a low-priority, high-utility command that I first made in Bard: the trace command. trace just prints out where in the source code the program is executing and/or the given arguments as a string along with what each one evaluates to. That sounds a

I just added a handy feature to Rogue: a named parameter passing mechanism that's focused primarily on the passing and receiving of logical (boolean) flags. It reduces the amount of code that must be written and makes coding more intuitive and self-documenting. I use logical flag parameters quite often to

Today I encountered the "age-old" problem of wanting to be able to use a StringBuilder as a key in a lookup table keyed to strings. Working on the new Rogue Plasmacore, my message passing system transfers byte arrays containing various strings. Many of the strings are the same every frame,

Overview I just added fallback methods to Rogue, where fallback methods are getters and setters that are invoked unless a property of the same name already exists. The Gritty Details Up until now access methods (getters and setters) have always trumped direct access to properties, but fallback methods are a

Because I can never remember.™ CommandDescription git checkout -b develop Create a new branch develop and switch to it; can be done after local modifications. git push -u origin develop Push the branch (after committing). git branch See existing local branches that have been checked out or created. git remote

This morning I realized the flaw in my IntX scheme that I presented in my last post [https://abes-codeblog.ghost.io/a-better-intx/]. First I realized that my algorithm wasn't working for non-negative integers that were a multiple of 7 significant bits and that my test cases were sloppy that way.

[Edit: I've changed my mind about all this; see Even Better IntX [http://abes-codeblog.ghost.io/even-better-intx/]]. I've always had some go-to technique I call IntX Encoding for compressing integers into a variable number of bits (fewer on average) but the specifics have changed over the years. Old Ideas Originally

files files files

I decided to add "modules" (AKA namespaces) to Rogue to be able to start making some auxiliary libraries without worrying about name collisions with end-developer code. Here's the syntax - pretty straightforward and C++-esque: # AlphaBeta.rogue $module Alpha class Value ... endClass class XYZ ... endClass $module Beta class Value ... endClass

A few weeks lately I caught Sudoku Flu on my Microsoft Surface Pro [https://www.microsoft.com/en-us/store/apps/microsoft-sudoku/9wzdncrfhv60] and it spread to my iPhone [https://itunes.apple.com/us/app/sudoku/id366247306?mt=8] and my Mac [https://itunes.apple.com/us/app/sudoku-deluxe/id410038420?mt=

On occasion I find myself needing to be able to take a list of data and generate permutation number n of all possible permutations. I've developed a neat, simple algorithm to do so and I've added two new List methods to the Rogue Standard Library to make generating arbitrary list

I've made a couple of additional improvements to Rogue's native support. First I came up with an even better way to inline native code. You write native("...")->Type (the return type and parentheses are optional) and the compiler not only throws the string into the output C++ code with

With Rogue I'm achieving a long-standing dream of being able to embed native method implementations within Rogue source in a simple way. There are now several ways to hook in native code; I'll briefly touch on them all using a series of examples. Rogue's primitives types (Real, Float, Long, Integer,

Rogue now has a nice new ability in its object-oriented tool-set: the augment. Originally appearing in Slag, I've brushed off the augment and expanded its capabilities. At its simplest you can use an augment to define a single class in several different pieces. Any properties and methods defined in the

My original ideas for supporting optional values were based around the concept of what I call a "null-checked block" - an 'if' statement or similar structure that would naturally guarantee that a null pointer access would never happen because 1) only optional values could be 'null', and 2) you would