Waking Up Late

8 10 2015

So; last year (not over yet) has not been the most prolific year in terms of blog posts. But things did happen. Things in the industry like Gamergate, like freedom of creation, a discussion regarding privilege mostly debated and fought over by rich kids with trust funds who have no idea what the word oppression actually means and discovering I’ll not touch publications like Polygon or Kotaku with a stick if my life depended on it any more. The kickstarter revolution and the indie-apocalypse and more fun games that I love/d playing (and some less fun games I suffered through). All of which I’ll probably write a post about one of these days.

On a more personal note; my kids grew up again when I wasn’t looking. Zeve is in kindergarten now and an avid watcher of a show called Qumi Qumi Land which is, let’s be honest, a platformer without a player. That is to say, I utterly approve. Skye switched schools, again, starting 3rd grade in a public school and she seems to be doing quite alright. She’s also enjoying her first [kids-level] MMO and well, I gotta say it brings a smile to see her enjoy gaming. What else? Ah yeah, we moved apartments. I got hit by a car. You know standard stuff…

Getting hit by a car sucks. Broke both the tibia and fibula in my left leg and now I have a intramedullary nail. Look it up. I’m facing 4 months of physiotherapy left (out of 6) but progressing. I can now walk with only one crutch and around the house mostly without crutches at all. I’ll tell you this (you, the invisible reader of this blog, most likely me in a few years), I never realized how much we take walking for granted; the little motions and angles. I no longer take anything for granted. I feel every single point of contact and movement required for a step. Ouch. If there’s one piece of advice to take from this rather rambly post it’ll be: “don’t get hit by a car, it’s not fun”.

Still working on Buck. We’re getting closer to release. Still working on other projects. Still doing freelance work when I can. Started helping on a little prototype for something called Red Heaven. Go check these things outūüėÄ

But where do I go from here?
I’ll continue a more formalized discussion on the concept of “game” without vexing lyrically. I’m going to write more code posts. I might slip in a couple of posts about where I stand politically and why. Who knows…

“why I’m staring out your window with a suitcase in my hand”





Less lyricism

22 03 2015

Anyway, I’ve got heaps of stuff written down concerning games and game design (not to mention development). But it’s going to take more time to sort through and put it up in a more coherent way. I’m not really into the whole “stream of consciousness” style of writing. Nor am I much good at it to be honest. So, let’s chuck it up to a failed attempt and press forward.

In the end; and bottom line; games have interesting goals and use interactive systems to provide narrative which sit on top of a world simulation.

Blargh. There are plenty of games which can be considered games just not very good ones. I put “Gone Home” under this category quite firmly. Along with many other “games as art” games. Your mileage may vary. I hope it does. Accepting that diversity of opinion exist is a requirement for actual growth (rather than surrounding yourself with people who always agree with you).

Next on the program? Not sure.

“And he never did do a lot of harm in the world, but he never did do no good, people didn’t think too much of him”





Vexing Lyrically Some More

10 02 2015

I’m not really big on philosophy. Sure, I’ve had my run of it when I was younger. Attempting to define the universe and feeling quite grand about it. It’s not that I think philosophy is not important; on the contrary, I feel that these attempts are a strong force in driving us forward. But these days I also tend to adhere more to the Mel Brooks Perspectiveūüėõ

With that out of the way; let’s disseminate some more on my idea of games. And digital games in specific. In which I attempt to derive my understanding of a what game is by mostly trying to figure out what lots of things which are not games are.

I’ve already introduced a category for scientific experiments; which are clearly not games (especially the blow-up-in-you-face-and-two-city-blocks kind of experiments). Science attempts to answer questions by simulation of conditions. Games also provide an underlying simulation in order to provide interaction – interaction being a most important part of games. But this alone is not enough.

Let’s go on another tangent (because, why not?)

Flying an airplane, be it a fighter jet or a commercial one, is no joke. And definitely not a game for the pilots who are responsible for many many lives. And yet. And yet flight simulators exist. Are all flight simulators games? That’s an interesting question. Do we treat all flight simulators as games?

The first and probably biggest difference to notice between flight simulation games and real life is the absence of actual responsibility/personal danger. These games provide a safe environment to participate in an experience which is usually not available to their players; another element, escapism of a sort (or fantasy).

So to iterate; as their name imply, simulators have at their core the concept of simulation. But as we’ve seen before, simulation is not enough to make a game. What other elements are provided by simulators. Abstraction. Fantasy. Safe.

There are, of course, further elements which can make simulators better at being games. And as the simulation level increases I suspect that the “game-ness” of the product decreases. I wonder if realism is somehow a force working in opposition to gamism.

Well, more on that later. Real life is in the way again.

I was walking through the counters of a national concern, and a cash machine was spitting by my shoulder





Vexing Lyrically

21 01 2015

I’ve not used this blog much for personal note keeping; trying to stay on course as a technically oriented space. But maybe that’s not the only direction I should take?

Been thinking a lot about games lately; the definition of the word, the people fighting to define it, etc. So let me vex lyrically for a few lines about this. Disconnected, disjointed and even nonsensical sentences may follow.

A game is played. The “play” of a game is governed by rules. To play a game means to interact with the game and with other players of the game. The game rules govern these interactions. Without rules there is no interaction, without interaction there is no game. This is not specific to digital games but is applicable (and indeed was applicable first) to physical games. All “things” in real life are interactive because of the universe’s inherent physical rules. But not all things in the universe are games (though most interactions can be made into games). It follows then that the physical rules of the universe (or any) are not enough in and of themselves to render something a “Game”.

In science we perform experiments. These experiments are set in order to test particular results from given conditions. These experiments mimic universe rules and environments and allow those performing them to interact in order to see results. This is a simulation. An experiment is NOT a game (although, again, may turn into one). It follows then that simulations are not games; this is not to be confused with the ‘simulation’ game genre, something I’ll touch on later.

Hmm…
More ideas are bubbling around in my mind but alas I shall continue them later.

“I was in another lifetime one of toil and blood, when blackness was a virtue and the road was full of mud”





First in a new year

1 01 2015

We survived through another revolution around our beautiful yellow sun.

I’ve not updated this blog as much as I wanted or as much as I needed.

I did, however, opened up a separate site for talking about Unity stuff. Can find it here.

It’s been a tough year to be honest. But we push through and carry on. May the code mines of 2015 prove richer yields than those of yesteryear. And may the coffee rivers flow free.

But when I get home to you I find the things that you do, will make me feel alright





Editing Project Files

19 11 2014

I find myself in a common situation where I want to open all of the .csproj files in my source directory for editing. My editor of choice is Sublime Text¬†and I’ve got a customized environment to help me locate all of my development tools via common paths (I think I wrote about that in another post, if not I’ll write about how I set up the environment in the next post). I could write a batch file to handle that via the Windows cmd, but I figured how hard could it be to write a small tool in C#.

It wasn’t hard at all and took about 20 minutes.¬†For me it’s a¬†win. So without further ado, here’s the main parts of the code.

public static void Main(string[] args)
{
 try
 {
  var files = GetProjectFiles();
  var files_path = GenerateExeArgs(files);
  var exe_path = GenerateExePath();
  Process.Start(exe_path, files_path);
 }
 catch (Exception e)
 {
  Console.WriteLine(e.Message);
 }
}
private static string[] GetProjectFiles()
{
 var root = Directory.GetCurrentDirectory();
 var files = Directory.GetFiles(root, "*.csproj", SearchOption.AllDirectories);
 if (files.Length == 0)
  throw new FileNotFoundException("No .csproj files found under current directory");
 return files;
}
private static string GenerateExeArgs(IList files)
{
 var files_path = "";
 for (var i = 0; i != files.Count; ++i)
 {
  var filename = files[i];
  files_path += " " + filename;
 }
 return files_path;
}
private static string GenerateExePath()
{
 var sublime_dir = Environment.GetEnvironmentVariable("sublime_dir");
 if (sublime_dir == null)
  throw new NullReferenceException("could not find the %sublime_dir% variable");
   var exe_path = Path.Combine(sublime_dir, "edit");
 return exe_path;
}

Alright. Not too much to comment on that. Note that I do have a sublime_dir environment variable already declared. And the use of Process.Start() to run the executable.

“I fell for you like a child,¬†Oh, but the fire went wild.”





Counts your lines!

5 10 2014

Type, type, type… Compile… Coffee… Type, type, type…

Eight hours and thirtey commits later. Blink. Stretch.

“Hmmm… How much code did I write exactly?”

It’s not really a useful question to be honest. The quality of my (and your) codebase is measured and quantified by better values than the infamous “Lines of Code”. Bill Gates was attributed with saying that measuring programming progress by lines of code is like measuring the progress on a Boeing by measuring its weight [not a direct quote]. And I agree. But sometimes it’s still fun to weigh things.

My first thought was running the analysis tools in Visual Studio. The numbers they crunch go further than simple LOC and weren’t really that interesting. My second thought was google. But alas, too many results and not enough time to go through them. It was then that I realized. Hey, let’s reinvent the wheel!

With that in mind I started a new console project (this is going to be written in C#) and decided to being with the simplest thing possible. Checking if I can read all files under my current directory and output how many code files there are.

public static class Program
{
  public static void Main(string[] args)
  {
    var root = Directory.GetCurrentDirectory();
    var paths = Directory.GetFiles(root, "*.cs", SearchOption.AllDirectories);
    Console.WriteLine("Found {0} code files", paths.Length);
  }
}

That works. Note in particular that we’re searching just for “.cs” files. And under all directories.

Next we need to actually count all lines in the files.

  var line_count = 0;
  Console.WriteLine(":: Counting Lines of Code...");
  foreach (var path in paths)
  {
    using (var reader = new StreamReader(path))
    {
      while (!reader.EndOfStream)
        line_count += 1;
    }
  }
  Console.WriteLine("Found {0} lines of code in {1} files", line_count, paths.Length);

And that should be it, except it isn’t. Our little program will now count all lines in all files. ALL lines. I don’t want all lines. I want to count code lines. But wait, what do I mean by code? For our purpose with this tool we’ll take it to mean any line that is neither empty nor a comment. To do this we’ll introduce a new method to query whether a given line is considered for counting.

public static bool ValidateLineIsCode(string line)
{
  if (string.IsNullOrEmpty(line))
    return false;var unspaced_line = line.Replace(" ", "");
  
  if (string.IsNullOrEmpty(unspaced_line))
    return false;

  if (unspaced_line.Length == 1)
    return false;

  var ch = unspaced_line[0];
  if (ch == '/')
    return false;

  return true;
}

And yeah, it’s not perfect but for my coding standards it’s pretty good and gives me a decent metric (albeit a useless one) for LOC.

It was always summer and the future called; We were ready for adventures and we wanted them all








Follow

Get every new post delivered to your Inbox.