Friday, November 30, 2012

Advice

Yesterday I hit the pavement around Champlain to talk to some of the professors and get some feedback. And overall, feeling pretty good. Gameplay is solid now, don’t have any more lingering worries about it besides actually teaching people how to play (I really am not looking forward to building this tutorial system).

Sound is now becoming the biggest concern, we have two potential people who are helping us already, but that dec 15th deadline just keeps on coming closer...

UI changes feel pretty good, the player selection stuff needs some work, but overall a way better system. Just being able to see a full preview of the map is great.

So today…

Polish up player selector thing, make sure the menu stuff with creating your own maps functions correctly. Had some rumors that the undo button wasn’t working yesterday, potentially squashed it so lets see how it works now, and finally im starting to have thoughts on team games… 2v2. Hmmmm.

Thursday, November 29, 2012

User Interface

One of the most fundamental aspects of games, yet one that rarely receives any attention. The User Interface (UI) guides a player through your game, it is represented with every screen you ever show the player.

Yesterday (and through today) we have completely broken down the main collection of menus, player selection, map selection, and even the way users access the map editor, and collected it all into one very nicely designed screen (thank your Marguerite). This is a huge step towards reaching some milestones on the polish side of things.

With this update players are now able to see in real time the map they are about to play one, not just small previews, which means that players can view the entirety of the battlefield before committing to starting their game. This not only works with the standard maps that come shipped with Overflow, but any additional maps users now create.

Speaking of which, there will now be six save slots per map type. Players can make a total of 18 unique maps, all of which can be reedited at any time.

Player picked colors will be next on the list!

Wednesday, November 28, 2012

Polish

Looking at our timeline as well as the gigantic list of things to do it was time to figure out priorities. Which means unfortunately the work towards Async will have to be postponed. As cool as it would be to get async in there it’s more important that we have better menus.

One of the biggest rules in usability design is that more screens separating the player from the game the higher the chance that they won’t even play. To avoid this we are combining the player selection screen with the map selection screen.

This would give players the opportunity to select their own colors as well as potentially their own symbols. The other addition that will be coming is a quick play feature which will instantly load the last map that was played, to expedite the process of getting players in the game even faster.

The last really big ticket item is a tutorial…

I really don’t want to make one. I know that it is super important, possibly the most important aspect of the game because it’s so key for new players, but it is extraordinarily boring to do so. But the thing is, I’ve got to make this look polished as heck, because we are going up against some really good indie studios for this Boston Showcase. So I’ll bite the bullet and make the stupid tutorial.

Tuesday, November 27, 2012

Evolution

One of the challenges that was plaguing Overflow was a clash of identities. The original design, which is currently called “simple” was great in a lot of aspects. The rules were like the name implies,  were simple, 1+ 1 == 2, 2 + 2 == 3, etc. However there were problems. Player 1 had a distinct advantage (given that they knew what they were doing), because due to the nature of turn based rules they would unlock their special tiles. Which means that player 1 could dominate the board and there was no way to stop them.

So along came the second iteration, nicknamed “complex”; which, just like the original design had its own improvements as well as flaws. Complex changed the rules of how tiles interacted with one another. It became a game of simple math, 1+1 == 2, 2+1 == 3, 3+ 1 == 4. However when any number combination == 4, the tile(and all adjacent lvl 3 tiles) would wipe to 0. Which was really satisfying, because now you could actually counteract the moves of other players.

A fourth tile was created in this version that could only be placed on lvl 3’s, and would basically solidify the board. I added this tile to ensure that the game actually ended; otherwise it was possible that players would infinitely block one another from winning.

The biggest shortcoming was that the rules became murky. When placing a tile it would effect the board differently depending on it the tile was placed on your own pieces or an opponents. Ultimately, while fun, it was incredibly difficult to break into and understand.

Thanksgiving rolls around and I start thinking. What if we mash the two game types together? Create a hybrid of design?

Well, that is exactly what I did. The game plays like the simple version, but has the fourth tile and the ability to counteract/stop other players from winning. The new addition will be available soon, I need to figure out how exactly I’m going to approach tutorials in the future.

Monday, November 26, 2012

And we're back

Great holiday for everyone, super relaxed and now all prepared to jump back into it.

Played alot of Overflow and now have a new punch list of sorts. So over break i started to tackle some of them:

1. Symbols? The major problem with art is that the game is still difficult to explain to people. Its very mechanical: A level 1 tile + a level 1 tile == level 2 tile. To counter this i started to play around with new symbols.

2. End Game Early: Now when you end a game early it shows the break down of who won.

3. Player positions: Players were originally set up in a Z formation, now its a clockwise circle.

4. Starting to work out an Undo Feature! After playing on an iPad over break, it became apparent that because Touch is so finicky its almost necessary. In addition it allows players to experiment and learn. The undo button will be a toggle option, on/off.

5. Thinking about bumping the medium map to be a large map, and create a new map size somewhere between small and medium.

So off we go! Things to do and now that December 15th deadline is looming closer.

Monday, November 19, 2012

Adjusting the Async Strategy

Friday was mostly spent understanding how Smartfox operates and ensuring that I could make the necessary calls to and from the server. But as I dug deeper into what it offered and began to understand more and more what Overflow actually needed I discovered that Smartfox was not the right direction.

Smartfox has some really cool features. Player connect to a lobby where they can browse the games and then connect, which is ultimately what I do want. However, it does it all in a way designed for real-time multiplayer scenarios. I began to look over the async tutorial again and discovered that he was only using the Smartfox as a hand off between the client and his database. He was not actually taking advantage of any of the multiplayer functions Smartfox came with.

So Matt and I really started to break it down and have decided to ditch the server and instead send calls out directly to a PHP page which will add, subtract, and edit the database for us. We are doing this for a variety of reasons, 1. We are both far more comfortable using PHP. Yes, we will have to figure out how to make it secure, but just getting async working is the goal. 2. The server would have required us to keep a machine running 24/7 and we would have probably had to start paying to use Smartfox. It allows for 20 concurrent users for free, which is at the end of the day only good for testing purposes.

The other good news is that if we get this system working, not only will it work for Flash, but also for Unity. Killing two birds with one stone.

Friday, November 16, 2012

Keep on going

Ok, round 2 for async, here we go. The challenge today is to have the client request something from the server and get a response. From there it’s requesting something from the server, which in turn requests something from the databse. But one thing at a time.

In other news!

Guild Wars 2 is rolling out a huge amount of content today, creating a new zone for upper level players as well as introducing a new dungeon along with ideas/armor/crafting material. Yay!

Thursday, November 15, 2012

Server Code…

Dove into the async tutorial I found the other day: http://www.indieflashblog.com/how-to-create-an-asynchronous-multiplayer-game.html . For the record I have never done anything remotely like this before.

The way it works is with SmartFox, server software that is built to talk with Flash. Downloaded/installed and started parsing through the tutorial text trying to get a handle on how everything works. Unfortunately the indieflashblog tutorial completely skips over how he learned to write serverside code, leaving a little note saying that if you want to learn that go look at SmartFox’s own documentation.

I created a simple MYSQL database on our website, no problem there; I did some PHP server stuff while working for Champlain. The problem that I just smashed my head against for the past three hours was trying to get the client (ie the game) to talk to the server.

Smart Foxes documentation is ok, but flawed because it doesn’t show ALL of the code you need, only snippets. I kept trying to communicate with the server Zone I had created, but it kept telling returning a non-useful error that had 0 google hits….

The other issue is that most of the code written is created on the timeline! WHY?!!! NO ONE DOES THIS! For those who don’t know, writing code directly in flash is a nightmare. You don’t the dozens of useful features like code hinting that have been around for something like 20 years. I code in Flash Development, a program that creates external classes.

Writing AS3 in the timeline and in external classes is almost identical, but every once in a while there is some big differences (importing external libraries, tracing statements, etc.)

Finally ripped open an example file and discovered that, while I was successfully connecting to the server, I was not properly logging in as a guest… which the smartfox documentation failed epically to point out.

So after this minor victory, I’m going home. Brain is too tired to keep coding.

Here goes nothing

Two weeks ago we hit the white board and planned out everything I thought was going to be possible for us to have in Overflow by Dec 10th, our deadline for the Boston Indie Showcase. The major elements were local multiplayer (check), differing map sizes (check) and a host of small nitpicky things (tutorial overall, selection UI overhaul, etc). And as of yesterday I feel confident to say that Overflow has nailed them all! Which is impressive because two weeks ago we thought it would take us right up until December.

So now it’s time to shoot for the moon. Expect no further daily updates after today, because I’m going for the big one: Asynchronous multiplayer. Here goes nothing.

Wednesday, November 14, 2012

Modes

We now have two separate game modes available for players to try out, complete with their own rules/tutorials (available as of yesterday). Simple, is just your normal everyday Overflow. Complex, on the other hand, is a slightly different animal.

The changes in gameplay evolved for a variety of different reasons.

When I was first watching people playtest Overflow, stacking a lvl 1 tile on a lvl 1 tile they immediately tried to stack another lvl 1 tile on a lvl 2, thinking it would change. Now, that is possible.

But getting to the lvl 3 state was too powerful, once a player did so there was nothing anyone else could do. To counteract this, a new 4th tier tile has been added. These dark colored tiles can only be played on tier 3 tiles, and when they are they transformed to a 4th tile state, which replaces the old 3rd tile state.

By doing this, games become longer, more strategic affairs that cause players to chose between sabotaging one another or permanently securing territory.

Over the next few week we will be play testing the modes, seeing which is more popular and making a decision on which will be the final version, but for now they are both freely available for you to play (your can do so HERE) and experiment with. Please let me know what you think @ zach@birnamwoodgames.com or at our facebook or twitter.

Tuesday, November 13, 2012

Timeline

We are approved! Apple has said that Overflow is good to go!

So now it’s time to figure out a timeline for releasing stuff out to the press along with what shall be going into the next build to push to Apple.

Need to get some more screenshots for the game for the press kit and we should really labor to create a good gameplay video.

Content wise, yesterday saw a pretty big update! Huge art pass, multiplayer colors were tweaked and we added horizontal slashes to the tiles in order for people to determine their level easier. Overall it has a much cleaner appearance.

The other major piece was that this weekend I was secretly working on a new game mode, which is now available to play around with. This, “complex” mode arose from several different factors that I had observed when new players first got their hands on it. I’ll go into it more later, right now it’s all about what falls on the punch list and when should we push to Apple again?

  1. Create a tutorial for Complex Mode

  2. Be able to choose mode & number of players after editing a map in the map editor

  3. Selectors are still not clear, cannot really tell that they are buttons.

  4. Tutorial Mode?


Hmm, well we will see what I can tackle today. The top two really need to happen before I submit again I think.

Monday, November 12, 2012

Workin on the Weekend.

Took some work home with me this weekend, had some concepts I wanted to play around with since I got some critique from the Champlain professors on Friday as well finished some major features. Now included is 4 player multiplayer! Which is really awesome. It changes the game dynamic in a lot of interesting ways, especially on the larger maps. Will find out the extent when I sit down to do a bit testing event sometime in the nearish future.

Priority list is now getting smaller, while larger aspects begin to loom. I found a guide on how to create Asynchronous multiplayer in AS3, no I’m not kidding. It was like finding the motherload. So that could be something I hit later in the week.

I want to add some additional options, give the game a timer, etc and this week I really want to figure out my color problem. Right now when you play the game it can be hard to differentiate between level 1 & 2 tiles at a glance. So I started playing around with color combinations and will be testing those out later this week.

In addition I may have fixed some of my efficiency problems. Originally every tile had a mouse event listener. Which means that there is a lot of them at any given time. What I got working this weekend was that the board now has a singular listener, when it detects a touch/mouse event it looks at the objects underneath and identifies the tile. Maybe zooming and scrolling will work now, who knows.

Friday, November 9, 2012

Realities

Much of yesterday was taken up by me just trying to understand touchevent.TOUCH_Begin & touchevent.TOUCH_End functions in AS3. Thanks to my little black box test program, I have a pretty good understanding of how dragging and zooming is supposed to work in flash.

Unfortunately that test has proven that my code is probably not very efficient, which kinda makes sense. Every single tile is continually getting pushed data like whose turn it is, what the selected tile they are holding, etc. So it comes down to a painful decision. Either rewrite a good chunk of my base code :( or leave it.

Looking at everything and thinking about the future reveals that the flash version of Overflow is essentially all throwaway. It will be replaced and until that point it just needs to work and look good doing it. The hot fix for the moment is that the iPad maps are just zoomed out so that all tiles are visible, though they are a bit small.

So onward!

Time to get four players into the game!

Thursday, November 8, 2012

Hitting that Wall

Uggg. Getting a smooth scroll/zoom in flash is turning out to be more painful than first imagined…

I came into with high expectations, flash has built in multitouch gestures for pinch as well as swipe. However both of these actions are not smooth. You make a swipe action, and once you finish then it moves the canvas, not in real time. I’ve tried a variety of different methods and ultimately nothing has produced the same effect that all tablet users are used too.

So today its back to the drawning board, im going to open a new project and have only a single square to test this with. Trying to build it into the existing framework of Overflow has been tricky and who knows if anything else is somehow prevent the smooth motion of these actions.

Also Critiques! Headed to campus to go get some other outside perspective on things.

Got some other stuff done yesterday though, here are the updates for Overflow:

-          Added 6 additional maps, 2 per each additional map size

-          The game now will end the game if one player seizes more than 50% of the playable map with level 3 tiles

 

Wednesday, November 7, 2012

What’s next? – Overflow Part 3

On our white board right now we have a good sized list of next steps as well as a wish list of wouldn’t that be awesome. It all comes down to what we can accomplish in Flash, which is what I’m fluent in, and what would require a switch in engines.

Yesterday I added the ability to create maps of various sizes in the map editor which allowed Mike and I to send the last part of the day just having fun crafting new maps. There are now four available sizes, small, which was the old standard, medium (22 x 24), large (32 x 28), and Marathon (40 x 35)! Which is pretty ridiculous.

So today is all about getting those maps playable through the menu and making the same editor updates available on the iPad, need to add some movement control stuff for that to happen. Everyday ill continue to make these little modular updates, seeing how far we can push the design and polish it up before our next big deadline. As of this moment we have a little more than a month before submission to the Boston Indie showcase ends, so it’s all a matter of how much we can pack in. As I’ve said from the beginning, we want user feedback of any kind. Please let us know what you think, what you dislike, or what you would like to see added in the future, on either our Twitter, Facebook or via email @ zach@birnamwoodgames.com

Tuesday, November 6, 2012

Concepts Part 2

Everyone is saying it’s a bit like Go, or even that dot game, the one where players draw connecting lines between points and try to create squares. Which is interesting, because while creating the idea neither of those came up as inspiration.

I’ve played Go with Taylor and my biggest problem with it is that the game is so slow.  The Dot game comparison is closer, because when comparing them, players both have chances to create chain reactions that would drastically change the field of play.

What I wanted to create was a basically a digital board game. From the very beginning I had this image of two players across from one another in a coffee shop, playing on an iPad. In pursuit of this vision I did a few things with the layout.

  1. As few as text as possible, most of it is represented through iconography. The quit button is an X, the rules are a ?, each of the maps include a small diagram of what they are beneath them.

  2. The unlocking tiles have the color slowly fill in addition to having a numerical value, so just by glancing at it the player can see if it is filled or not.

  3. Player’s pieces are on opposite sides of the board. If they are indeed playing across from one another, players don’t want to reach across the game board, obstructing the field of play in order to select their tiles.


The beautiful thing about the game is its simplicity. The primary game loop, is less than 600 lines of code. Each tile keeps track of its current state, its owner, and knows whose turn it is and what they have selected. It all comes down to incrementing tile states. If its player 1’s turn and they have a level 1 tile selected and they click on an empty space, it becomes theirs; the tile is flipped and turned the correct color.

For each tile there is only a finite number of states. The cool thing about the game is dynamic nature of changing those states and causing cascade events.

By Tuesday I had it working all working and realized that we could actually put it out for distribution. The game might not be feature complete, but players would at least get a taste of the gameplay and would hopefully give us feedback on what they like/don’t like or what they want to see added next.

So I pitched to everyone a deadline of Friday. I wanted to try what the Super Meat Boy guys did with the original SMB, a free flash game that was available on the internet that gained followers. And that is what we are going to do. Already, since the Friday deadline a whole new mechanic of differing terrain has been added! And soon to be uploaded will be a much better tutorial!

Monday, November 5, 2012

Thoughts on Overflow Part 1

So what happened last week was pretty spectacular and out of the blue; never thought that the production of Overflow would take off like it did. So many things just clicked and because of that we were able to meet our Friday deadline. So I'm going to try to slow down a little bit and look back at how all of this happened.

Turning back the clock, the days have been pretty standard for me. For a few months now I had been prototyping different ideas, some lasting a few day and others upwards of about a week. As a result my desk is covered with old printer paper with hand drawn maps, pieces of code, random words, and idea after idea for games.

I have always been a strategy fan; ever since my family refused to play board games with me anymore I dove into video games. Starcraft is one of my all time favorites; Supreme Commander was brilliant, backed Planetary Annihilation. And because of that I have always wanted to create a strategy game.

Overflow began as a very abstract thought, a water turn based strategy game. Water would pour down from higher terrain onto lower sections, taking them over in a cascading fashion. But what would create the water? Springs? Would they be water towers that overflow? Just kind of a lot of awkward questions that ultimately led me to abandon the idea.

But last week I started playing around in illustrator and ended up creating this:

This file is the game doc for Overflow. I began with some really simple, aesthetic colors and tried to differentiate, yet keep them in similar shades. When I created the first color spectrum the water idea just came back and I knew I could use it in an abstract form.

Immediately I grabbed some graph paper and started cutting out little pieces, colors for one side, numbers for the other to make it easy to differentiate them, and then Mike and I sat on the floor and played it out.

Friday, November 2, 2012

How much can we pack in?

So today is the day! Some time around 1 or 2 we will be uploading to Apple. So now its just a matter of seeing how much I can pack in. Yesterday I got side tracked by having to debug another application for JDK, but overall here is what was completed:

1. Ownership bug has been stomped! You can now stack level 2's on one another!

2. Cascading chain reactions! Now you can see exactly how one move impact the game board.

3. A map editor was created and was what I used to create the three additional map types.

The map editor took the majority of the as I have never made on before. It saves a player map out to an XML file which i can then read back in. I tried really hard to figure out how to get player created maps in, but it just didn't end up working out. In flash I cannot get the selected map URL link when a player clicks open.

Go check out these updates HERE!

So today i need to go back and start commenting code, hard code the map types in for iOS development, and Matt suggested a great temporary way to get people playing their own maps.

 

Thursday, November 1, 2012

Punch List

So yesterday ended up being very productive. The tile game has been christened and named Overflow. Play it HERE, if you haven’t already.

  1. A Proper menu was created

  2. A pie chart at the end of the game was added to show how much a player has won by.

  3. Switching between players has been made a bit more obvious.

  4. You cannot get locked in an infinite loop of instruction screens.

  5. A reset button/functionality was added.

  6. The game was successfully deployed to iOS and runs exceedingly well on the iPad.

  7. Basic tile flipping animation was integrated near the end of the day.


So overall, got a lot done. Even got some testing feedback last night which was even better. So now the bigger decisions need to be made, what functionality needs to come next?

Well, I believe I’m going to first make the overflow mechanic give more visual feedback. Right now when a stack spills over, the tiles flip instantly. What I always wanted to do was show the cascade, this set flips, which causes this set to flip, so on and so forth.

The next big question riding on the heels of this one is what after? And at this moment there are two choices, 1. Add more players (support for up to 4) or 2. Add additional maps, shapes, terrain features that would shuffle up the players experience every time.

If you have any crazy additions you would like to suggest please let me know, either on Facebook, Twitter, or at zach@birnamwoodgames.com.