Learn Build Play

Short Cycles in Agile

2011-04-11T00:01:00.000-07:00

Agile methodology is a widely used system of project management. While there are many facets of it, this article intends to explain the values of short cycles and how to apply it in your own projects.

An issue with Waterfalls…

Most of us have been involved, or even headed our own, Waterfall project. A Waterfall project is where you start building your project, with your nearest goal not being any clearer than the project is ready to go. Waterfall means that once you have your plan in mind, you try to build the whole thing in one go.

The problem that we face is that if the project takes any length of time, we, or others involved, make changes to how it should work. Small surface changes are fine, but often these changes will affect the basic architecture of the project.

On with Agile…

In Agile, we use small cycles of development, called iterations. Each iteration will select only a few features, usually of the highest priority first, and make sure they are working. The objective is that each SMALL iteration will be completed, and can be tested by the project owners at each pass.

When they try it, they can make requests for the next iteration. These requests can be to either make changes, fix bugs, or change the priority of existing items. But once the next iteration begins, and the tasks have been selected, it is locked down. The developers need to be able to focus on these tasks, and architectural plans without interruption until the completion of these tasks.

Many teams make the mistake of allowing changes during these iterations, but the development teams should strongly protest. The PM’s and involved business side should be making plans for the next iteration based on reports, and not pushing immediate changes during daily updates.

On the individual level, one thing I like to do, is to select a single task, simple and high priority, and finish it before jumping on any other task. Then test it. I have been applying this to all my projects now, and had excellent results. Because I don’t have multiple tasks going on, I can walk away from a project for a while, come back, and I will either know the one tasks I was working on, or most commonly, all previous features are completed, and I can do whatever I want to next.

One common feature that has spawned from this is a clear version history in all my personal projects. I use this numbering system: #.#.#[.#]. The first number is the release version. It is always 0 when I first start, and goes to 1 when I make the first release. The second number is the feature or bug number I’m working on under the current release. 0.1 is the first starting item, usually just creating the project, and potentially adding one class, or shaping the UI on one form.

The third number is the date or time. If the project is very small, I might just include the hour and minutes, but usually this is the date, as in 4 digit year, 2 digit month, 2 digit day. Finally, I have an optional trailing number for multiple releases during the same time, particularly for testing.

One thing this has helped show me is how much time it really takes me to build something. I’m often caught by the idea (at least in the past) that a certain project will only take me a couple days to finish. If I measure in hours, I might imagine 12 hours of dedicated work. But when I look back at my version history, I begin to see a different tale.

The project starts out great, but then reduces in speed. For my personal projects, that is mostly because of real life, such as I have a real job, or I need to make dinner, or I’m heading out for a little while. It even is because I have just lost interest in the project for a little while. But it gives me a good look at the reality of how much time it takes. Even If I really only worked on it for 2 hours, if it took me 2 weeks to finish it, that’s really how long it takes.

But at work it’s a different story. I often start to see a loss of time near the end of a project. What I began to realize is that management increased the amount of time spent on meetings. Literally, 2 extra 30 minute meetings where added to check on statuses, but then an extra thirty minutes of time was spent to make sure the information was ready. Of course email distractions also increased because of the number of important emails being sent around, and the massive of numbers of people being added to the email chains.

By taking an agile approach, at least for yourself, you will begin to notice how you really work, including an additional level of focus and speed in projects. The version history, gives clues to how things really operate and the single task orientation allows for focused approaches that leave you with clean places to work, and re-evaluate your needs often.

Games Limited to Upgrades

2010-05-24T00:00:00.000-07:00

    Its very common place for games all over the place to focus on upgrades as being a key feature in their game. And unfortunately a lot of games have been showing up without much more concern for keeping the game fun.

   There is an underlying psychology to this. People have a basic need to feel like they have accomplished something, to give a value to something they did, even if that reward is imagined.

   But many of them have lost site of anything more than that. The users need a clear goal, or series of goals. But above that, it needs one key rule, "Fun".

   There are a thousand rules you can apply to making a game good, but Fun should always be the first.

- Weird I suppose, but I think this is all I needed to say. Don't worry: everything after here, including this line, is not important, so you really don't have to read them, or this.

- So your still reading? OK. That's fine. I'll spend a little time telling you about certifications with Learn Build Play. Most places certify you with a multiple choice test. Not here. Here we break it into 3 main phases.

   Phase 1, Project. You build a project covering the key topics included in the courses leading up to the certification. We check that the project accomplishes everything you said it would.

   Phase 2, Screening. You send us your resume, and we review it, then setup a fake phone screen with you, as if we were hiring you for a position similar to what your certification was surrounding.

   Phase 3, Interview. At this point, we do an in person interview with you. All you need to do to get certified is pass the technical side of the interview, proving that you understand what was needed.

   We will give you tips along the way, but not only that, we give you solid feed back on your interview by giving you an assessment of how you did from the interviewer's perspective. This includes places to improve, so you could get the best results from a real interview.

   After all, whats the point of getting certified, if it can't get you a job?

Learn Build Play is on its way...

2010-04-26T00:00:00.000-07:00

I plan to start teaching nightly classes in the very near future. Learn Build Play is getting ready for it. It's anywhere from one to three months from now for its first class, as I’m getting everything else arranged and the site built up, but I figured now would be a good time to start talking about it.

A little background on me, I’ve got over 10 years of professional experience (what I consider being paid to program/administrate/test). I have about 20 years of programming experience. (I started with Basic in the 4^th grade, and never looked back, unless I thought some one called my name, or I forgot something.) And about 6 or 7 years ago, I started teaching part time at colleges.

I personally hated much of school growing up. I never went to college and it took me 5 years to finish high school, almost 6. I had a saying all through high school, and beyond it, “Education is the most important thing to me and I’m not about to let school interfere with that.” I’m really fortunate I didn’t let school get me down.

I learn differently than many others, but not too differently. Some teachers were great; everyone learned a lot, had fun and gained a drive for whatever the class was about. I also had the good fortune to move around a lot and see different schools, probably 10 different schools in 12 grades. I got to witness lots of teaching styles.

Over the years, I started to learn myself better; to understand how I think, how to change, how I react, where I’m weak. On a chance moment, I learned about the Continuing Education at Heartland Community College. I signed up to teach Visual Basic 6, which used to be my strongest language. I was one of those “forever” supporters of it that didn’t want to let the language die.

Over the next 3 years there, I took a game programming course that was essentially a 3 classes a year of learning hangman in visual basic, and turned it into a successful 10-20 classes a year game programming series. It used various languages, VB6/.NET, BlitzBasic/+/3D, C#.NET, and covered a variety of technologies such as graphics, physics, rendering, binary logic, networks, AI and more. But most of all, (I believe) my classes were fun, engaging, and provided my students with a drive to learn more. Most all of my classes received top performance evals.

When I got a job offer to work at Microsoft, it was actually a hard decision to make. I did not want to leave this place. But on the other hand the largest company on my resume required me not to name them directly, I could only say, “a large insurance company in central Illinois”. As far as I was concerned, Microsoft was the End-All-Be-All in the computer world. Not the only one, but similar to being offered a position at Porsche (pronounced ‘Poor shuh’) or BMW, as they are pretty top end.

Eventually I decided to take it, but not until haggling with them for a week over pricing. Once I got up here, I settled down, and it took me a year before I got to start teaching again. This time with Bellevue College, where I’m still teaching to this day (part time contracts) for game programming.

I enhanced their existing course and expanded it. But I have not had the flexibility I have been hoping for in class offerings nor many classes to teach. With these classes, I’m hoping to be teaching more often. I still plan on staying a senior SDET at Wizards of the Coast, but my evenings will be doing the activity I love most, teaching.

The classes will be 8/9 person max, each person will be provided a laptop in the class. We will have a server environment, typically 2-4 hours in length, and you can get certified. The certification program I have in mind involves building a project on your own, which covers the key topics of the Course, followed by a few questions by phone/in person, then an interview for a fake position mirroring the course. While the technical skills are all that is required to get certified, a follow up description on areas to improve, including interpersonal skills and interviewing tips are all part of the course.

What’s the point of getting certified in something if there is not a reasonable shot to get hired for it? No multiple choice test. Anyway, I may post again several times prior to its activation, but it is on its way. I’m presuming the first class in June.

Getting Better by Giving Less...

2010-04-19T00:00:00.000-07:00

One problem that many people face is giving too much to their goals and projects. We create one small goal for our project, or our game, but then we sit down for an hour and really think it through. Every “good” idea we run across becomes part of the final project. And you start to realize that the first draft of the projects financial needs are in the millions.

Bloating is one of the most common causes of failures in a project. Even if it had another fault. Imagine throwing similar resources at a smaller project, or developers, architects and testers time line differences, when the project is not only smaller, but simpler as well.

This is all “fine and dandy” but how do we actually apply it? I’ve understood this principal for years, but haven’t been able to figure out how to apply it until recently. Whenever I would start building a game, I would try to start small, but the architectural excitement factor draws me in. It is exciting to keep adding more, and unheard of to remove the things you come up with along the way.

So here is what I have started to do with my plans. I give in to my need to design awesome architectures and super simulations, and design full blown systems that I will eventually decide are too complicated. Then I simplify them. I start to cut out all the crap I don’t need. In movie editing, they have a phrase, “you start cutting with a scalpel, and finish with a sword” I reverse this. Start with the sword.

In fact, skip the sword and start with a rescue squad. Salvage what you can. Pick the most important part of the application. Then the next couple of items, and rank them. Next, reconsider what you really need to accomplish that.

I have this bad habit of wanting to rent servers instead of websites, whenever I start building a site. If I were to get a server, my options would open up more. I would have so much more available. But do I need it? I’ve never run more than 4 sites at a time, and site hosting VS. a dedicated server is a whole decimal less in cost.

Its not cost effective, it created more work, and I ultimately got less done. So this time, I’m considering a site again, but I’m only considering Hosting a single site. I’m paying 1/10^th the cost, and I have less of the stress. I’m not dealing with fail over systems. I’m not dealing with security. I’m not dealing with Maintenance. Huge amounts of the work are cut out, because I’ve decided on a course of action that accounts for the minimum requirements to get the same end result.

The Same end result? I cut my cost by 90%, my time by 50%, and my work load by even more. I’m considering exactly what I want the consumer to see, and what EXACTLY is needed to provide it. I’m also considering what I have tried and failed at. What’s the last LARGE project I’ve completed? None. When I let my projects bloat, they fail, not from complexity, but from neglect. The potential stress of trying to get it to work, makes me rebuild it from scratch or just move on to another project entirely.

One of the reasons many of us get into programming or game design, is because we see things as they are and want to add to it. Whens the last time you’ve played a game and said, This would work better if it had this… When is the last time you played a game and said, This would work better if we cut this feature out. Its easy to cut out obviously annoying things, but what about things that don’t really help the end goal of the game? What if we were playing in a game with wavy grass, where the grass images came from 256x256 motion tiles, instead of 512x512. Would we really see the difference. The second takes up 4 times the resources, and the end user might not even notice.

So, take a recount of past projects, and consider what the last project you designed was that bloated, and was it successful? My advice is this, start small, stay simple and then scrap all the requirements that don’t help the ultimate goal of the project.

Mentor's Learn the Most

2010-03-29T00:00:00.000-07:00

One thing I’ve always loved doing as a teacher and mentor is, “Let’s try it, and see what it does.” I often learn things I wasn’t expecting, or get new ideas. There are many more reasons, but it’s time for all potential, practicing and professional programmers to stop thinking so much about how they will get their own tasks completed, and start thinking about the ultimate success of the company, teams and projects.

Even from a greedy perspective, helping others in the companies makes sense. Helping others makes you a reference, or a known expert. But, it also generates social connections, puts your name higher up on lists and introduces new opportunities.

But from a practical sense, it is even better. You learn new ways of either doing things or not doing them. You get good examples of both good and bad work, beyond what you have done on your own. You get to experience other coding dialects within the same languages. Everybody you work with will often have some valuable perspective that you can learn from.

So here are a couple rules of thumb to make sure your applying.

*Always listen to the other perspective. Try to imagine that the idea they are talking about is yours, and imagine ways that it could be made to work in different areas. When you come to blockers, you’ll have really effective means of challenging it. Not to mention you might learn something.

*Try something new. Technology and how it relates to the world are constantly changing. You should never believe there is any form of end-all-be-all solutions. You’ve probably worked with someone who knew they were right about something, and wouldn’t even bother to look at another perspective. So don’t be that person yourself. Everything in life changes, all the time, whether we want to perceive it or not.

*Be willing to help when ever reasonable. When we join a company, or a project, we are telling the rest of the team that we will do our part of the work. So what does it mean if you get all your stuff done, but let everyone else fail? Try to imagine that you are not yourself, but a part of a larger form, that is working towards one goal. This will help you take the “I” out of TEAM. Besides, if it’s a quick fix, you’ll be done really fast, and if it is not a quick fix, you’ll learn something from it.

*Let others know that they can use some of your time if they need to. Just being available to help isn’t enough when many feel that seeking help, is embarrassing, and that others will probably just mock them, even just subtly. Did you ever ask someone something, and they give you a look or expression that says in a mocking tone, “You don’t know how do to that?” It is tough. But if you make sure they really believe that you are open to assisting, that you see the project as a whole, they will be far more open to seek help faster.

Now, take a step back and imagine most of the difficult scenarios family and friends. Apply this same logic. Imagine how much it would have helped. This is my basis of being a mentor. It is my opinion. I welcome you to apply it, learn from it, improve it or challenge it.

Perfect Code

2010-03-22T00:00:00.000-07:00

In almost any industry, everyone is always looking for shortcuts for what they need to do to get the customers what they want. This is both a good and bad thing, and you must learn recognize what is good, and what is easy.

For instance, building games, you have options, like selecting a previously existing game engine, or producing a new one of your own. Another might be, Should we produce the hardware for this game, or use existing platforms or OS's? Another might even jump further out and say should we use existing graphics processor chips, or design and build one ourselves. The short cuts in all these would be to ultimately accept an existing engine that already works on existing hardware.

While there are many directions I could go with this, I'm going to take another direction, and that is in our every day choices, particularly for programmers. I've discussed the use of standards in previous articles, but once they are set, we are often faced with the decision of skipping ignoring it for speed.

When I worked as an electrician, Dan Webster, the guy I was training under, "If you don't have the time to do it right, you certainly don't have the time to fix it." So why do we find ourselves stepping out of our self-imposed standards when programming? Because we have two stages of development, and we need to learn to keep them separate, those being: Practice and Perfection.

You've probably heard this one, "Practice makes perfect". Since perfect is a strong word, I'm not going to debate its philosophical implications. Instead I'll offer this meaning for how I'm using it. Perfect Code, is code that you can fully defend every line, every capitalization, every comment as to why you have used it in specific, and that you would trust this code in production.

While we sometimes produce Perfect Code, we often tend to produce Hack Jobs, just piecing together code in any way that gets it to work as quickly as possible, or Band-Aid code, as my wife calls it, because it may be gushing problems, but this dinky little band-aid seems to keep it together for the moment.

We need to face facts. We are not as good of programmers as we think we are. "The only true wisdom is in knowing that you know nothing" – Socrates. Compare some of your own code. If it was part that you have done a hundred times, you will find your code is naturally cleaner, closer to something that you consider Perfect Code. But if it's the first time you've created it, you'll tend to find shortcuts all over the place, little hack jobs. You often tend to find yourself going back over it to clean it up and try to bring it up to your Perfect Code standards.

So what does this mean? Here is a good rule of thumb: If you find that you aren't following your "Perfect Code" standards, because they are tedious while you are building this part, then forgo ALL of your "Perfect Code" standards, and call it a practice. Once you have figured out what works in the code, go back and do it right.

If you find yourself heading in the direction of practicing, in your real project, copy the whole solution over to a temp location to try working on it. Once you have completed a solution once, go to your real project and rewrite it, only following all your standards. It is impossible to follow the Perfect Standards, while your knowledge is imperfect.

Why use standards and which ones?

2010-02-15T00:00:00.000-08:00

An entity without standards is chaotic. I’ve seen, experienced and even generated my own projects that had no standards (back in the day). From all these, I’ve seen some common traits:

1) If the coding takes long, like more than 16 hours, it starts to get complicated to work through and keep things in the bit of architecture you originally intended.

2) You find that as you move along, you need/want to rebuild parts of it to simplify them or just because that part doesn’t make sense to you anymore.

3) After leaving the project and coming back, or entering a new project from someone else built the same way, you tend to think it would be easier to rebuild the whole thing, than work with the existing code.

4) You lose track of the meaning behind certain methods, classes, variables and processes, and when you look at it, you don’t understand how it seemed so clear at the time.
5) Bugs start showing up all over the place.

6) You start applying little hacks here and there that keeps things working in very specific conditions.

7) Fixing a bug usually produces two more, 1 you get to see right away, and hides out for a little while.

8) If any timeline was generated, it has been exceeded.

9) If the project isn’t very important, the developer will drop it.

10) Developers get sick more often due to stress.

11) It is fun to start, but after a short time, the fun is gone.

The list goes on…

If you find your code, team or other’s suffering from the symptoms, it’s a pretty good sign there is a lack of a standard (at least a good one). I’d also like to point out that a programmer without standards does not make them a bad programmer, but it does make their code more susceptible to the symptoms above. Just like OOP is a step over the basics, having solid standards is a step above that.

So I’ve listed some of the bad things that happen. Now on to the solution.

When it comes to standards, I’ve got a saying. There are many right ways, and many wrong ways, but only one right way. :D (it makes sense in a moment) The point is that while there are many good standards to follow, you have to choose one and stick to it. Standards are no good if they are not standard. 2 weeks ago, I posted a way to document standard processes. (here) Now I’m going to give you some ways to find and keep your standards in specific.

The first thing is to know why you follow something. There are many outdated standards, which are outdated for good reason. The second is to be open that your own style might not be the best. (This is something I consider all the time.) Hungarian Notation was pretty big for a while, until they realized (not everyone knows this) that by following Hungarian Notation, you are actually reducing the implications that should be used through vocabulary. Lets take a look at 2 variables “_adAmount” and “prices”. Looking at the Hungarian Notation on the right, which is using an “_” to show it is a private variable, “a” to indicate it is an array, “d” to indicate it is of doubles, and “Amount” to give it a name. Now, following some more modern standards, we see “prices” which is lacking all the symbols and details of “_adAmount”. It is lowercase, indicating it is private. Price indicates a decimal is needed and also implies the accuracy needed of a double. The fact that it is plural implies an array of some sort. Both of these followed a standard. Hungarian got away with “Amount” though. Amount is questionable, amount of what? Amount of time since the last loop? Amount of apples? There is nothing in Hungarian Notation standards that sets up the implications of its meaning.

Sure, you could have chosen “_adPrices” as your variable name, but what standard are you pushing that requires that? Another developer may have entered this and just used “I” or “x”. The point is that the word is often chosen because the developer needs a “notch” to refer to for a variable. If it’s only for a single method, they often use smaller less obvious terms. While these work great for the quick entering of data, in order to figure out what it is, you have to take a look through the code to see how it is used. I recommend keeping a standard where things make more sense, and are easier to read with native English.

Now to the key point, 1 true standard. The point is for you to write down your standards that you will follow. But, you also need to record the defenses with it. (Why this is best) And finally keep it open for critics. Anyone who works with you, should also follow this standard, or successfully argue why to use something different. You are not allowed to use a “because I said so” or “because I’m above you”. The whole point of this is to make better code, not stick to some obscure ideology you grew up with, because you aren’t open to change. Be practical. When you write down defense, also include challenges to it, even if you keep that one. Later on if you find a better way that solves more, then upgrade and keep it. Don’t hold to practices that are not defendable. You’ll find yourself hurting in the long run, and may not even realize it.

One Standard: All standards are defendable, or they are not standards.

One Standard: All standards are open to change from anyone who has to use them.

One Standard: Have a standard.

One Standard: Keep it practical.

One Standard: Keep it Easy to find, Easy to read and Easy to use.

One Standard: KISS: Keep It Simple Stupid.

One Standard: Keep it flexible.

One Standard: Keep it living.

Open-Book Management

2010-02-08T00:00:00.000-08:00

I just finished reading a book called Open-Book Management, by John Case, which I originally figured I would read the first chapter and decide I already had a lot of the ideas that the book would have to promote. I was wrong. When I first selected it, I saw it as keeping open with employees, and keeping a clear goal and vision. While that is important, this book is actually about Money.

It taught me several things about how to keep employees driven at all areas. I’m about to describe part of the book, but by all means, not even close to covering it. If you find any of this helpful, GO BUY THE BOOK. You won’t regret it. If you are trying to exist as part of a company, run one or are starting your own, you have a responsibility to make that company successful. Especially if you are running it.

While there are many who want their companies to be successful, there are few who actually make companies that want to be successful. The difference is small, but very clear. Think of any random gas station, or fast food place. At the corporate level, you have lots of people who are running around trying to make the company succeed, and exceed in its industry. Now imagine the cashier, or the person who made your sandwich. What do they care if the company is thriving or not. If they only get 25 people in that day, instead of 500, they’ll be happy, because its less work for them. They get paid the same whether they serve 10 or 100 people an hour.

Now think of the customer. Does the customer care one bit about how much the corporate layer’s are doing to try to keep the company afloat? No. They care about the service they get. They care about the quality the sandwich was made. They care about the speedy handling, and the accuracy of their order. Corporate can do all they want to “streamline” and provide the fastest method to deliver the service, but it really is the employees that give the customer their clear feelings regarding the quality of the company.

So what can you do? How can you make all the different people, EVERYONE that is part of your company, interested in making the company succeed? Open-Book Management starts with opening the books, the financial books. Exposing the numbers for all to see. Then training the different areas to be able to clearly understand how certain parts of it affects them. As well as starting some kind of profit sharing.

There is no part of any company, that is there without having some effect on the bottom line of the finances. If you can show them how they have a direct impact on the success of the company, and give them goals to improve their area, and if their area improves, then they can get bonuses from it, suddenly it is not just a job, but a goal. The average employee will see that they can have a real effect.

If the person doesn’t care how the company does, no more than guaranteeing their paycheck anyway, it is only a job. If they want more jobs, there is a section for that in the news paper, online services dedicated to finding new ones and networking to find more. But if your company provides them with a strong feeling of connection with the success and failure of the company, then you’ll be able to retain employees longer, there will be more open communication, more areas will be found that can improve.

There is another key to this Open Book Management though, empowerment. You need to give people the power to actually make change, at least in their own areas. You need to keep open communication between all layers of management about ideas that could improve the company. Honestly, who is going to know better about how to save money at the customer service level, the employee who is working it every day, or the VP sitting 3, or more, layers up?

The higher a person is on the management ladder, the more power they should have at shaping the company as a whole, and primarily deal with keeping communication up with those that report to them. It is more often that management thinks that the lower levels of the company need to be directed, told what to do, when more often than not, they just need the initial training, and someone to help keep their obstacles cleared.

If you get the chance, I recommend reading it, as the author explains through many stories, how this can be applied, and what issues people went through to get there.

Documenting Processes...

2010-02-01T00:00:00.000-08:00

To my readers, I have spent a long time refining my own processes, and now I’m trying to come up with a standard way to document it. I’m going to suggest a standard documentation practice, and ask for insight and considerations in the comments. Like any process, or method I follow, I’m open to criticism and suggestions. Things work best when more than 1 mind is involved. Too many things in this world are of sheep. Once something is created, all the sheep follow. Don’t be a sheep, comment on this. :D

I recommend using a Wiki, and that each part of the process be its own document. Now, I’ve worked for lots of different companies as a contractor, and have seen many good and bad practices. Ultimately it comes down to usability. If the people can’t or don’t use it, it won’t matter. All documents should have 3 directives, if and when possible.

1) Keep things clear.

a. Do you get the point of it?

b. Is it confusing?

2) KISS (Keep It Simple Stupid)

a. The more specific something is, the less it can be applied, and therefore, the less it will be applied/retained.

3) Keep it short.

a. I’ve worked at a company that there entire process was clearly defined, with around 8000 documents. Each document had an average of 5 pages of explanation, and it often took 10 minutes of reading to understand the basics of it.

b. Take your most vital and basic explanations and put that at the top. Then, if more space is needed, Re-iterate at the bottom. Most people don’t need to know the details.

c. This does not mean to cut out necessary information, but simply to allow the fastest use of it, and more info when needed.

My general structure would follow this means:

1) Include the documenting style

a. If the style changes over time, this will let you know how this was intended to be displayed, for past editions.

b. This is a reference to an explanation document that follows the same format that it describes.

2) Give it a short/clear sentence for a title. It should include key words. Less than 80 characters if possible.

a. This is the document title for links, or the file system, as well as a headline/title for the page.

3) List the exact steps that are the same as often as possible.

a. This should be bulleted and short, anywhere from 1 sentence to 8. If it is more, consider whether it should be split into more process documents.

4) List Prerequisites

a. This should either be 1 line explanation of what was needed

b. Or it should be a link to another process, that always needs to precede this.

5) List Follow Ups, which is just like the Prereqs, except that these are things to do next.

6) Optional references.

a. This is where links go that you do sometimes. List the most obvious condition(s)

7) Detailed statement of why this is being followed.

a. This should be a bulleted list,

b. Each Item should include sub items that either defend or challenge it.

c. This should be open to being challenged by anyone,

d. Challenges should not be removed.

i. They should include the reason they are not following this.

e. If need be, this section should become its own document, if there is too much explanation.

I like the idea that all reasons are defendable, and if we *have* to support something that we challenge, we should know why. All politics should be stripped from this. Only fact, and purpose.

Another thing about this is that for some projects, a area of the general process documents might not apply, and may cause undue stresses and difficulties. In those cases, the project should include a document outlining the needs for a change, including the process (in the same format) of what they are changing and following the same model for giving supporting reason’s and challenges with it.

Finally, This needs to be flexible, and ANYONE who works with this process NEEDS to have the right to post challenges. Things change, better ways might be found, and this allows the processes to grow over time.

To recap: This is an initial draft for how to document. It follows many standards that I have seen succeed, particularly in the areas it was best suited. However, I am one man, and one island. No general process should be made by me, or anyone, alone.

By all means, post any ideas or concerns. :D

Data Sources

2010-01-25T00:00:00.000-08:00

When storing data, there are typically 3 major choices, Databases, XML and custom Binary Files. I’ll be discussing several pros and cons to each method. I will also be discussing a 4^th option that has been recently emerging, involving living network data.

Before emerging into any as the end all be all solution for your project, you should look into the values and strengths of each option. Weigh them carefully, once you select a route, it is often very difficult to change it later.

Databases are very good at storing lots of information, and being able to pull it out very quickly as well. It is very common and simple for most database system to hold on to millions of records of data and search, sort and update very quickly. Most databases follow a simple language called SQL for retrieving, inserting and editing data, which (when taught well) is not difficult to learn. Databases can also be expanded to additional machines to help improve overall performance in larger systems.

Databases tend to lock the format of your data down. It becomes difficult and time consuming to continually change and support databases as they grow. Typically this produces a decent amount of administrative work. Data storage be wasteful. (if 5% of your users use 3k for a description field, but the other 95% only use 0.5k, Every row still requires 3K, whether used or not)

XML is very flexible to data formats. If you are constantly updating and changing data, XML can provide a solid system to work with it. If you format your changes well, saved files can be forward and backward compatible with different versions of your application, without needing to write additional code to support it. XML is humanly readable, which means that a notepad can easily edit and read the data for you. Not only is it human readable, but it is descriptive, so just by looking at the XML file, you can determine what and how it is used, making it easy to edit files from programs you didn’t write. XML is also easily transferred over the Internet, saved locally on any machine and is supported quite well on Every reasonable OS and programming language.

XML is not intended for large amounts of data. When reading it, it all has to be parsed and stored in memory. Because of this constraint, it is often not easy or fast to conduct searches of XML. XML is stored as plain text, which also means it takes up more space. Since Lengths can be anything, your program has to be written to expect any length. Also, data types like numbers and Boolean values are stored as strings, so they have to be specifically converted into numbers. XML is also a poor choice when storing and loading binary data, like images, sound files or movies.

Custom Binary files have been used for a long time. This means storing the data (typically) in the smallest amount of space it possibly needs. It also means that it is harder to use outside of your own applications, which is often helpful for protecting local data. You control entirely control the format, and can decide how best to shape it, making portions of it similarly searchable like a database, and other portions flexible like XML. When storing large amounts of data that will only be used by your application, this is a common practice to use.

Custom Binary files lock you into a format. Any changes you make have tend to require a decent amount of code to transfer from one version to another. They are difficult to read, and if bugs are caused by misplaced data, or some accident in writing the data, the entire file can be ruined. It does not allow your data to be easily read by other systems, which could be negative depending on your user’s needs and interests. They also require more design time because you are not only deciding the format of the data, but also writing all the tools and code for handling the data.

A fourth option I referred to as “Living Networks” is demonstrated quite well by a system called “Terracotta”. The reason I selected a particular brand name for this, is because it is new (and old, as similar concepts have been around for a while) system, that I have not seen a valid competitor for yet. In this system, it manages memory over multiple networked servers. It has proven faster than the best databases when the data is designed for it. It is also flexible like XML, and also provides (by its nature) redundancy and load balanced data access. It is a system that I look forward to in the near future becoming a new standard for data storage and retrieval.

Terracotta only supports Java, leaving C++, C#, VB, PHP and other languages out. Because of that lack of interoperability, when selecting this, you are forcing your data to be accessed through JAVA/J2EE alone, meaning your data has now limited your application choices, not very sustainable in mixed environments. It is not intended for home computing and should not be considered a solution for local data.

Each of these 4 data solutions target different audiences. Even within these systems, we are not very technically mature. It should be noted that every one of these areas is coming out with new and better ways of storing information, (XML being an exception) and will continue to do so for a while. While one solution might be the most optimal at the moment, improvements in other environments may make them your optimal choice a year later.

Game Text...

2010-01-18T00:00:00.000-08:00

This post has to do with a Human Text reaction system. It was a common tool used in many telnet games, as well as similar principals are pulled in from Intellisense, and even web searches in some places. It’s the ability for the application to determine ideas of what you meant from less letters than even a complete word. A simple idea is a text based game that you have to constantly move East, West, North and South. It would be a pain for the players to have to type West 20 times in order to go from one city to the next, so the words can be “shortcutted” (interesting word). Instead of typing in “west” you could just type “w” and it would determine that the most logical word is West, and treat it as if you had typed the whole word.

I happened to build one out of boredom the other day, so I figured I would share that. The code is fairly well documented, so this is only going to cover the principals, and basic use of it. First off, it should be noted that this needs more than a light understanding of C#. It’s using Events and Delegation, which is roughly the same as turning methods into variables so they can be set, replaced and passed around.

Essentially, the first word in a line is a command. In my case I chose the word “Verb” to name the class for it. Essentially a Verb is given a word that it relates to, and then it is tied to a method, so if it ever gets triggered, it will call that method. That part only requires a simple understanding of delegates. The next part of the complications was in the “Manager” class.

The Manager can hold multiple verbs. When a new verb is passed into it, it looks inside its list of verbs and places it in Alphabetic order. So if you added West, then North, then South, it would be sorted as North, South, West. A command called Execute in the manager separates out the first word from the text passed into it, then compares it against each word in its list to see if it matches up. So, when I type in “s” for south, it goes to the first word, and compares the first letter, “s” does not equal “n” (the first verb being north), so it moves on the next word (south) and sees that the given letter “s” matches. Once found, if executes that verb, passing in any additional text that was with it.

When the manager is created, it needs a verb to execute incase it doesn’t find any matching verbs. So if I typed “X”, which has no verbs, the manager would trigger the “unknown” verb.

There is one step farther. Some words are used far more commonly, like North, South, East and West for various games. (The words would be different for different systems) Given this, I wanted to give priority to certain words over others. Let us say that my game had a command called “Next”, which automatically reads the latest message or something similar. My players now have to type in “no” at minimum for the system to know they meant North. Or worse yet, perhaps there is a verb called “Norse” if my game has certain mythological tendencies of some sort, now my players have to type in “nort” before it recognizes “North” as the verb.

The priority system is simple. If you want 2 levels of priority, which should probably be the most you ever use, then you create a “PriorityManager”, with 2 priority levels. This class would then create 2 managers, and assign each one a priority. This system treats the lowest priority as the lowest number. It also uses 1-Based indexes, instead of 0-Based indexes. It creates its own unknown verb for the managers, and when one manager doesn’t know the word, it passes it all on to the next. If it gets through all the managers unsuccessful, the priority manager calls its own unknown, to let the system know that the command is unknown.

The attached project was written in VS 2010 Beta 2, as many of my personal practices and projects are now written in that. I believe it is free for everyone to download from Microsoft, but the CS files are easy enough to import into C# Express 2008 or 2005.

Download the Project Files Here

Collision Detection...

2010-01-11T00:01:00.000-08:00

There are many ways to do collision detection in games, but only 1 I recommend. 1 method literally prints both images over each other, and checks each border pixel to see if its colliding with another from another object. Imaginably, this can take a while. Another checks each boundary as a box and uses basic if statements to determine how effective it is. The third, and one I will recommend is using a Pythagorean distance checking formula. First, I’ll get into the bounding boxes, and consider what it takes.

With bounding boxes, you make the presumption that each of your objects fit within a rectangle. Each object gets a location vector (Vectors were discussed in a previous article), and a Dimension vector that defines the rectangle’s height and width. In order to compare the bounding box, we need to find out if any part of the box in inside the other.

To do that it is somewhat straight forward, but repetitive and with small changes. Essentially, you need to consider each border. And whether or not it is inside the other box. Lets Presume, the following Object Fields: Box.X, Box.Y, Box.Width and Box.Height.

The first part is easy. Are either of the vertical sides of Box2 to the right of Box1.X. If either are to the right of the left side of the box, it has the potential of being inside the box.

Boolean CollisionDetection(Box1, Box2)

{

If Box1.X < Box2.X OR Box1.X < Box2.X + Box.Width, Continue checking;

}

Another way to write the same line, is to decide to stop checking, Like so:

Boolean CollisionDetection(Box1, Box2)

{

If NOT (Box1.X < Box2.X OR Box1.X < Box2.X + Box.Width), Return False

}

Essentially at each validation line of the collision, it can stop processing, to save work, when it has already determined that it can’t be touching. The line for determining the Top is almost the same as the height.

Boolean CollisionDetection(Box1, Box2)

{

If NOT (Box1.X < Box2.X OR Box1.X < Box2.X + Box2.Width), Return False;

If NOT (Box1.Y < Box2.Y OR Box1.Y < Box2.Y + Box2..Height), Return False;

}

Detecting the bottom and right sides are similar, and to make it easier, I’ll add a few variables.

Boolean CollisionDetection(Box1, Box2)

{

Top1 = Box1.Y;

Top2 = Box2.Y;

Bottom1 = Box1.Y + Box1.Height;

Bottom2 = Box2.X + Box2.Height;

Left1 = Box1.X;

Left2 = Box2.X;

Right1 = Box1.X + Box1.Width;

Right2 = Box2.X + Box2.Width;

If NOT (Left1 < Left2 OR Left1 < Right2), Return False;

If NOT (Top1 < Top2 OR Top1 < Bottom2), Return False;

If NOT (Right1 > Right2 OR Right1 > Left2), Return False;

If NOT (Bottom1 > Bottom2 OR Bottom1 > Top2) Return False;

Return True;

}

So this is checking to see if one box is colliding with the other. This includes checking if one is inside the other. Reviewing this code though, it takes at least 4 equations, and at least 8 if statements. So for every comparison you have 12 steps being processed. At 2 objects to compare, this happens only once, but with 3 objects, you’ll have to repeat this 3 times, and with 4 objects, 6 times. Lets presume the game has 20 objects on the screen that you need to detect collisions for, that means it has to run this 190 times. That means 760 mathematic equations and 1520 comparisons.

Its easy to see that this builds up quickly. It also limits your areas to boxes. Sometimes boxes are exactly what you need. This is often true of Map based games, where things are set on squares (even if the squares are not so visible to the player). But in free floating games, like flight simulators, water or space games, using circles is faster and easier. Don’t worry about Cosines or Tangents, this won’t require any Trigonomic functions.

Pythagorean Theorem is all that we’ll need. If you haven’t gotten to it in school, or forgot it, here it is; In a right triangle (it has a 90 degree angle) the hypotenuse (the side opposite the 90 degree angle) is equal to the square root of the sum of the other 2 sides squared.

In plain mathematics, the triangle below, C = √(A*A+B*B). In code, that looks like C = Math.SquareRoot(A * A + B * B);. The order of A and B don’t really matter in this case.

The next question is how to apply this to in our code. X and Y are also 90 degrees apart. Lets say X is A and Y is B. What you need is the X and the Y differences, and you get the points where A and C connect, and where C and B Connect.

In our new Game Objects, we will use location and radius or size.

//Game Object

{

Vector2 Location;

Float Radius;

}

To test if they impact, we will get the distance, and decide if it is greater than the radius of the 2.

//Compare Objects

Boolean DetectCollision(GameObject g1, GameObject g2)

{

Vector2 Diff = g1.Location – g2.Location;

Float distance = Math.SqRt(diff.X * diff.X + diff.Y * diff.Y);

If distance > g1.Radius + g2.Radius, return true;

Return false;

}

This code is considerably smaller. Vector2 math uses 2 equations for each equation we use on it. “g1.Location – g2.Location” is the same as “g1.Location.X – g2.Location.X” and “g2.Location.Y – g2.Location.Y”. There are 7 equations and 1 comparison when checking 2 objects. For 3 objects, there is 21 equations and 3 comparisons. For 20 objects there is 1330 equations and 190 Comparisons. So that is a significant improvement over bounding box collisions. (As a reminder, that was 760 Equations and 1520 Comparisons, for 20 objects)

But part of my statement isn’t true. Bounding boxes can work better in some conditions. For instance if the most common collision detection is between the player and everything else, and the player is typically at the bottom. Your first check can be the top border. If that fails, it can be only 1 equation and 2 comparisons. Which means your most average check would only be 190 equations and 380 comparisons for 20 objects. That is dramatically less. Bounding box comparisons can leave earlier.

I recommend implementing both systems for practice, and doing some comparisons early in your game to decide which works best and why. Do some performance testing on how it effectively works.

Vectors in Game Design

2010-01-04T00:01:00.000-08:00

When we first start creating 2D video games, we most often manage the variable X and Y for the object’s location on their own. While all physics can still be applied this way, it makes it more difficult, and usually harder to enhance your game over time. The modern world uses Vectors and for good reason.

A Vector is simple, it holds 2 or more numbers. For 2D sake, (since 2D has less to explain) we will use a Vector2. A Vector2 is made up of 2 variables, X and Y. The X and Y are used in more than just location; they are used for movement, dimensions and ranges. For instance, perhaps your game needs to know the screen size. At the beginning you create a Vector2 called Screen. At any time, your program can ask for Screen.X, which is the width of your screen or Screen.Y which is the height.

//Settings

Vector2 Screen;

Screen.X = 800; Screen.Y = 600;

Each of the objects in your game also carry a location vector, which defines where they are. At the drawing cycle of each game loop, it will find each object, and draw it based for its location.

//GameObject

{

Vector2 Location;

}

However, each of those are just setting a variable to identify a location. Screen defines the Bottom Right Corner of the screen (0,0 being the Top Left Corner) and Location giving exact coordinates for anything that needs to be drawn. Another perspective is Movement. Movement, or momentum is a highly valuable feature. My previous article discusses the use of momentum when applied to a single variable.

Imagine that if you pressed UP, it simply subtracted your Force variable (engine torque) to your Momentum.Y. (By subtracting from the Location.Y, you move the object closer to the top of the screen) If you pressed down, it added your Force to the Momentum.Y. This takes care of your momentum for speeding up and slowing down, but now I’ll throw another variable in, Handling. Handling will define how affective your steering is. When you move left or right, it will subtract or add your Handling to your Momentum.X.

(NOTE: “A += 5” is the same as saying “A = A + 5” it is a short cut in most languages used to reduce the typing for this common use.)

OK, now given past knowledge, we might just say location.X += momentum.X and Location.Y += Momentum.Y. With Vectors in programming, there are certain overridden operators, like + and – and * and \ and =. This means that I can say Location += Momentum, and it will Add the momentum to my location, taking care of both X and Y. If you are using DirectX, XNA or other game engines, this is probably already taken care of, but if you are writing your own classes, you will either need to add your own methods, or you will need to learn about Overriding Operators and add methods for +, +=, -, -=, etc…

//GameObject

{

Vector2 Location;

Vector2 Momentum;

Void Move()

{

Location += Momentum;

}

In addition to Adding Vectors, you can also Multiply or Divide them by a single number. Like Friction. Such as, Momentum += 0.85.

//GameObject

{

Float Friction = 0.85;

Vector2 Location;

Vector2 Momentum;

Void Move()

{

Momentum *= Friction;

Location += Momentum;

}

I leave this article off with a request for you to go try it. The only way to gain experience and timing knowledge is to practice this.

Game Physics - Momentum & Friction

2009-12-28T00:01:00.000-08:00

One of the natural progressions in game development is going from a locked speed to a momentum based system. Originally, you might have had code that made your ship move forward by 2 pixels every time someone pressed forward. It’s easy, done in a line of code, and you can forget it. But when it comes to upgrading your character, ship or vehicle, you are now faced with a lot of hard coded upgrades. Instead of moving 2 pixels, now you move 4 pixels. Etc…

I remember the idea of adding physics as one of those near-impossible tasks, primarily because I didn’t understand how it worked. Below, is the basic idea. To start with, I’ll commonly refer to the word “cycle”, which means that the game makes its decisions/changes, draws the frame, then moves on to the next. Each game loop is a cycle.

During each cycle, I check if the forward key is pressed. If it is, instead of moving the ships location by two pixels, I add 0.3 to a variable called momentum. So if I went from still, to pressing the button, the first cycle would move the ship by 0.3 pixels. During the second cycle, I add another 0.3 to the momentum, increasing it to point 0.6. That means this ship is moved 0.3, then 0.6, and next it will move 0.9, then 1.2, 1.5, 1.8 etc… This means that it smoothly increases. Suppose you are in a car. You want to be moving 35, but from 0, it doesn’t just happen the instant you touch the gas pedal. The car gradually accelerates. First moving only at 3 feet / second, then 6 feet / second, etc… until you reach 35.

// Game Loop

{

If UpArrow is Pressed, Momentum = Momentum + 0.3;

Position = Position + Momentum;

}

At this point, in your game, it will increase in speed until you let your finger off of the forward button. It will coast at that speed. As with proof of concepts, this brings up another challenge, the ship keeps moving faster when you hold the button. The speed gets unreasonable pretty quick. What you need to do is add a top speed variable. Let’s say TopSpeed = 2. Every time before you add the momentum to the location, check if the momentum is greater than TopSpeed. If it is, then set Momentum = TopSpeed. This way the ship never moves more than 2 pixels per cycle.

//Settings

TopSpeed = 2;

//Game Loop

{

If UpArrow is Pressed, Momentum = Momentum + 0.3;

If Momentum > TopSpeed, Momentum = TopSpeed;

Position = Position + Momentum;

}

A quick recap so far, you can add a Force variable, and when you press to go forward, it adds that amount to the momentum. This is now a variable you can set per vehicle, calling it torque, or how fast you accelerate. Your TopSpeed variable, which is pretty obvious, which is another easily upgradable value for your individual vehicles.

So next, lets add Friction. Friction isn’t necessarily something you need to add, but its excellent for

cars, boats, planes, etc… where you want the vehicle to gradually lose speed when the vehicle isn’t having the gas pedal pressed. Essentially, you add create a variable called friction, and it’s value will be 1 meaning no friction, or 0 meaning completely blocked. A good starting friction is probably 0.85. At the beginning of every cycle, multiply your Momentum by your Friction. Momentum * 1 = 100% Momentum. Momentum * 0.85 = 85% Momentum.

//Settings

TopSpeed = 2;

Friction = 0.85;

//Game Loop

{

If UpArrow is Pressed, Momentum = Momentum + 0.3;

Momentum = Momentum * Friction;

If Momentum > TopSpeed, Momentum = TopSpeed;

Position = Position + Momentum;

}

Friction is easily applied as an Aerodynamic feature for each of your vehicles, which is also easily changeable now, for each different vehicle in the game.

There are a lot of directions this can be taken, but I wanted to cover some others, like Force/Torque, Vectors and Gravity, in future articles. This is an article that is meant to be practiced. The basics are here.

Going Pro to Cut the Stress

2009-12-21T04:01:00.000-08:00

I’m going to take a stab in the dark here. You commonly face stress, because you don’t have enough time to complete the tasks before you. People, red tape, unclear definitions and even the environment around you create constant issues that prevent you from being able to meet all your commitments. This is one area that tends to separate professionals from the aspiring. (Please note: this is one aspect of being professional, as I see it, there are many)

I came up with the focus for this article from speaking with a friend who was having a lot of stress, and constantly finding themselves trying to do more than they could. Once it became clear to me what was causing this, I spoke with him about it and hopefully, helped him out. (Time will tell)

The first issue is that we don’t pay attention to the issues that block or interrupt us. When we look back at how long a task took to build, we ignore little things that interrupted or blocked us, because in an ideal world, those things would not stably be part of that task. Perhaps while trying to complete the documentation on something, we had to wait 30 minutes for an email verifying something, perhaps we were pulled away from our desk to answer a few questions for someone, who knows. The point is, that despite the fact the task itself was not responsible for the extra time needed, it was a stable part of the environment; you will always be interrupted by questions, you will always have to wait on emails, you will always have to [Insert random thing].

The first solution is to start realize that nothing is ideal. Every task you take on will have interruptions from delayed resources, unrelated requirements, unanswered questions, and more. Figure how long it will take you to do a task, then once done, look back and figure out how much time you spent focused on the task, and how much time the interruptions took. You’ll start to notice sizable differences. You’ll start to notice trends, 25% (or some other %) of your time gets taken by interruptions.

The second solution is to learn from your past. Until you pay attention to your past, your doomed to suffer from it. Your past gives you clues to help you realize how things will play out in the future. If you start seeing a trend of about 25% of your time is taken by things that are not important to the task at hand, then you can start applying more appropriate time lines. You could say this task will take me 1 hour to complete, but I estimate 15 minutes will be lost to environment issues. My total estimate is one hour and fifteen minutes.

Another source of stress deals with us wanting more. We want more and more and more. At home, we want to do all these things to improve our houses, our family lives, our health, our entertainment, our stuff, and our “fun” things to do. We find ourselves cutting it really close when driving, trying to shave off 5 minutes here and 2 minutes there, pressuring our vehicles and the traffic around us to get us there as fast as possible without getting pulled over.

The whole time, any interruption that creeps in, like traffic from rush hour, car accidents, unsure drivers, holiday traffic, and construction we find ourselves unhappy, stressed, and angry. But, we always know that things like this will happen. We tend to take the fastest time we went from point A as point B as the standard, while anything more is cause to raise your frustration.

Once you start realizing that chaos will always be there, you will start to see that a lot of your time is wasted in frustration, particularly relating to unimportant things. As you start to realize how long these things take, you will be able to apply a better standard in defining what you can fit into your day. You will have less stress and be more trust worthy, as people will know that when you say it will take you an hour to do something, you mean it, unless something highly unlikely creeps into view, and will more often be early, giving more time for reflection and relaxation.

Also, when you start applying seasoned experience like this to the work place, you will find that you will be able to identify time lines better, identify weaknesses better and provide clear reasons for success or failure. You will be more respected at work.

Often relating to our jobs, when we take on a task, we might think that it will only take X time, but once into it, we realize that there are issues we didn’t know going in. Perhaps it’s how large the learning curve is, or how slow the requirements are getting produced, or constant issues with the hardware we have to work with. Whatever the case, because we don’t pay attention to those as having real impact on our tasks, we keep getting stressed that our timeline is closing in, thinking *maybe* we could finish it in time. The whole time, we get closer, the possibility of completing it gets smaller and smaller, and the questionable area gets larger and larger, but we only focus on that possibility of success.

The 3^rd Solution is to keep others notified and be clear about changes. Whenever I take on a task, I always identify my confidence in completing it and try to have a small list of key areas I think might cause issues. I never go higher than 90% confidence unless it is a regularly occurring task, that does not have a history that varies much, if at all. By making your managers and coworkers aware of your confidence level, it opens up the possibility that that portion you are not prepared for will be more work than expected and provides a valuable safety net when things go wrong.

If you face issues about something changing, you can say you are going from 75% confidence to 50% confidence that it will be completed on time, because of X issues. Most people are afraid of looking like they don’t know something or can’t handle something at work, and will take on more than they should. Remember this, quite often the original numbers for a project or task were created by looking at a one or two line description and assigning a number off the top of some one’s head. Remember that when you agree to them, and apply the confidence level, you are being clear about your knowledge, making it better known whether you can finish something or not.

Answer me this, which is better, an employee who takes on a lot, gets most of it done, but often causes delay because they didn’t get it done in time (for [insert random excuses]), or someone who says it will take longer, who always gets the tasks done on time, baring something catastrophic. Sometimes, it’s nice to get the hacked work out faster, but most companies want people who know there limits, so management can really figure out what is needed, and what is possible.

Creative Story Tips

2009-12-14T04:00:00.000-08:00

It would be easy for most experienced writers and designers to come up with 1,001 tips for creating a plot, applying emotional attachments and filling in the content to make it work. But starting from the ground up, we are all different. We approach problems differently, and we've learned different things along the way.

So my first tip is to not take every tip you read as important, as something that is valuable to follow. Besides, a lot of people who like to give tips wouldn't even use it themselves. They suggest something that seems logical to them, but when it comes down to it, they don't actually apply it.

Always determine what works best for you. What do you feel helps you the most. What are you looking for?

So to continue on with a few more odd tips to consider, we get to used to summarizing things that we think we understand, even pushing a book down to a few sentences. Harry potter can be summarized as "Evil wizard thinks boy will defeat him, tries to kill him, and fails. Boy grows up, learns to survive in magical world, and destroys evil wizard."

Tip #2) Try writing a book you already know. Take Harry Potter for instance. I pick that because it is a popular book and uses a lot of well-known styles for making it an easy, engaging and fun read. Take any story where you know the plot really well and write it from the top of your head. Plot is often easy, but doesn't matter if your characters don't make your readers want to find out what happens next.

It’s a great way to test your abilities. Is it interesting? Are your characters engaging? Do other people find it an interesting read? If you have friends who like Harry Potter (or the story you choose) are they enjoying your alternative perspective on the story?

Tip #3) At many points you may find that you have written so many words, that the purpose you were originally trying to convey, may not be getting across very well because you wrote so many words to try to explain it clearly, especially when the same message is repeated, or importance of the added detail is unimportant.

PLEASE note that the previous paragraph was ONLY one sentence. Perhaps it would have been easier to say, "Don't use more words than needed to convey something." But I wanted to make a point. Often, we feel the urge to add more words. I use that as a sign that I haven't found the right words, and consider re-writing the paragraph, or omitting it.

Tip #4) everything has to flow. Directors often remove lots of great content from movies. Lord of the Rings for instance; Watch the normal movie, then watch the extended edition. It covers more, but you'll also notice that it doesn't flow as well, and you start getting a little more bored with it. It makes it not quite as engaging to continue.

You should re-read the chapters and pages regularly as you are writing, and seriously consider getting rid of any part that seems to flow a little slowly.

Tip #5) Readers of your story are smart, very smart. You miss something and they'll see it. But, if you over explain something; it is easy to risk boring them with details. When reading Harry Potter, I find myself often annoyed with little sections that say "And harry knew this because, in a previous book, blah blah blah." In most cases, repeating content is a poor choice.

Tip #6) Reconsider everything you hear, no matter from what source. Urban Legends start because someone suggested something that somewhere along the line someone else took literally and spread it as truth. The whole thing about "humans eat an average of 7 spiders a year when sleeping" was just a hoax made up to see if it would catch, and sure enough, lots of people took (and take) it as truth. Just because I say something doesn't mean it’s true. Most things are never universally true. Read with your own eyes. Don't just use my goggles, or anyone else’s, or you'll see no more in life, stories, creation or chaos.

Technical Interviews...

2009-12-07T04:00:00.000-08:00

So you need to hire a developer? You are either a competent developer yourself, or not. Either way, this may help you with some ideas about what to ask for. First off, I recommend a great book called High-Impact Interview Questions by Victoria A. Hoevemeyer. It gives an overview of different styles of interviewing, and teaches the CBBI (Competency Based Behavioral Interviewing) approach. I found that that bulk of the information needed is within the first few chapters. (at least enough to get you started, but I still recommend you read the whole thing)

To briefly go over the CBBI interviewing practice, I’ll give a couple examples. Imagine yourself in an interview, and the person asks, “How would you approach a really irate customer?” You would think of the most optimal way it should be handled, and speak along those lines. But what about this question, “Tell me about a time that you had to deal with a very irate customer.” It’s not a question, it’s a demand. And it’s not giving leeway for you to think of the most optimal solution. Instead, you have to describe what really happened.

Most of us can easily site what the most optimal reaction might be to something, but when you are actually in the moment you need it, what really happens? CBBI gets the person to tell us about real scenarios in a person’s background. Follow up questions like, “how was it resolved?” or “What did you do at X point?” can help you get the answers you’re looking for when the initial response isn’t satisfactory, or questionably false. (as the follow up questions may also get a person caught for lying)

So the next part is figuring out what is important to you? Obviously there are technical skills, but not so obvious is that the person needs to communicate their knowledge to less experienced people, or that they need to work independently a lot. You need to figure out what areas are important to you. (the book has a LONG chapter dedicated to different topics for questions, with example questions, like Communication, Empathy, Speed, Stress, etc…)

Now, hopefully, you’ve got a brief idea of how to ask some of these questions, but I still highly recommend the book, as it has a lot more content than my few paragraphs, and there really is a lot more value to it than I just provided. The next part I’m splitting into Skilled and Unskilled questions… Skilled covers questions and issues for interviewers who are already skilled as developers, while Unskilled means that the interviewer is not greatly knowledgeable in development work.

Skilled Interviewer:

To begin with, you should be aware of 2 key directions of developers. Both are highly valuable, but both may fail horribly if questioned in the wrong way. For instance, C# is a powerful, flexible modern language. It has roots in Visual Basic, .NET itself, and C++/Java. Naturally, your developers come from varying backgrounds. If the persons background came from VB for instance, they don’t often know the term “Hash Table” in VB, they used Dictionaries.

Many people have plenty of experience developing, but don’t necessarily understand the best word (according to you) for that scenario. I, for instance, was concatenating strings for over a decade before I realized it was called that. I remember being in an interview where the interviewer asked me about that, and I said I didn’t know what it was. Instead of asking me about my experience with string manipulation, he marked me down as being incredibly unskilled.

You may inadvertently discard a candidate who may be 10 times more qualified for the position, because your choice of words were not the same that they would use. Always follow up your keyword based questions, with a request for them to explain the mechanics. It is better to understand the process than the words. While words are pretty, the process is what really gets the job done. A skilled interviewer with strong symbolic memory, and a mental dictionary of keywords would excel over a person who actually does this stuff all the time.

Back to CBBI, remember to request that the person tell about real experience. This also helps you get off the resume. Sometimes a person has experience that they don’t bring up so boldly, because it isn’t attached to a shiny business name, but it was part of a failed personal project. Despite that, the skill is there. It is your job as the interviewer to find the best you can get.

It doesn’t really matter if you get the impression that the person will work out well. Any skilled interviewee can give you a great “impression”. That usually only says that they were good in the interview. Remember, as Charismatic as that person was, when it comes down to crunch time and not a hypothetical interview, you are depending on this person to reflect well on you, and help reduce the overall stress with their skill at getting things done.

Unskilled Interviewer:

First, you have to determine why you are hiring. If it is a larger company, and you are responsible for filling in a position that you know nothing about, that is a problem. Any skilled interviewee who recognizes that you know very little, can rattle off some strand of answers that are right, or wrong, and as long as they sound confident, you’ll most likely believe them.

If you’ve determined that you have to be in charge of it, then you NEED to find technical help. The same questions you look up online, are likely the same ones a skilled interviewee will find. If you don’t have someone immediately available, ask friends with these skills. Or, expanding farther, ask a company with some vested interest in your success, if they could get a little assistance in finding a person. Obviously, this won’t be a competitor, but perhaps a business client or a vendor. Getting in touch with sources like this, can actually help promote stronger bonds with your 2 companies, and help you get a better person for the job. This person could possibly just do a simple technical phone screen, spending 10 minutes per client, and possibly assist in a sit down interview for a few of them.

If your still stuck, talk to a recruiter. Have them do the technical screenings. Make sure the person’s resume shows that they have skills in the areas you are looking for. Call their past managers, and ask them how well they work on their own. (after all, if you don’t have resources to understand what they do, they could just sit around and make things up, with you none the wiser)

Next, ask them to explain things to you. If this person will work with databases, ask them to explain how databases work. Then ask them to explain how they get might be able to get it to work with your product. At a certain point, you can request, “Tell me about a recent time you had to do this, that you got stuck on an error and had to spend some time debugging it. What did you do?” naturally following up with other questions.

Since you’re asking them to explain something in the first place, ask yourself. Do you feel that you understand it better because of them? Remember to use a sliding scale on these things. Your first interview, you will understand the least, and as you interview more people, you will gain more theoretical knowledge. Remember to give each person that same initial question of “Explain [X] to me.” Though your follow up questions might be more in depth.

A skilled person should be able to explain how it works quickly, easily and clearly. Given how they are being hired, you need someone who can explain what is happening to you in the same manner. Whether or not you get help on it, if you won’t have qualified technical resources who can review and explain the issues available to you, you should still ask these questions to make sure the person will be able to convey the issue.

If a person passes the technical aspect completely, but can’t help you understand how a database works, or how a website gets built, then once they are hired, you can’t expect to be well updated by this person.

Controlling the Finances...

2009-11-30T04:00:00.000-08:00

One of the biggest problems in today’s world is the general populations inability to maintain a budget. While this blog doesn’t tend to shift into matters like this, learning to control your own budget will help you to control your companies budget no matter how big or small, and it will help you reduce your stress.

To start off with, I’ll quote a line from The Richest Man in Babylon, “part of all I earn is mine to keep.” If you haven’t read it, then I recommend doing it. I will say though, that it is based off of Babylon, which has slavery, and several chapters get somewhat graphic. I recommend at least the first 3 chapters, as the books starts off lighter. (The book is short, and to the point, using stories/Babylonian parables to visually explain the idea, making it easy to follow, and see why it works)

“Part of all I earn is mine to keep.”: seems a little off, isn’t ALL I earn mine to keep? The answer is no, of course not. Part of it belongs to the grocery store. Part of it belongs to video rentals. Part of it belongs to the gas station. Part of it belongs to rent. Etc… The point is, is that you don’t keep what doesn’t come back to you. Get away from the Monkey See, Monkey Buy stage.

What is recommended in the book, is to take 10% of everything you make, as soon as you get paid, and put it aside. Then, if you are in debt, take the next 20% and apply it only to pay off debt. Then don’t let your living expenses exceed what is left. It seems obvious enough yet difficult. We each get the idea that we need to save, and not spend so much, but we still do.

The problem is, that we do not do anything stable. We tend to just eyeball our bank accounts, paychecks, and really important bills. And then just pay out money as we make up off the top of our heads. While 10%, as the book recommends, is not so important as a specific number, it is somewhere to start. It gives you a very specific, very attainable goal. The reason it works is because it requires you to limit yourself. To pay more attention to your finances.

But there is more. That 10% you paid yourself with, you spend it only on things that will pay you back with interest. Gambling is NOT a good place. Your friends often are not either. More often than not, the loaning of more than pocket change between friends is a cause of great stress, and will eventually separate, particularly if the friend who required the loan doesn’t have means to correct the situation that caused the need in the first place.

What you need is to talk with people who have experience in investing. People who have experience in making money become more money. NO Get rich quick schemes. You’ll find that the most successful people don’t use get rich quick schemes. You want to find sources to pay out to that have a high probability of paying you back, with interest.

Then, all the money that the 10% budget spent on an investment, you put right back into that 10% budget. Then, take 10% of the profit, and put it into your account, and 90% of the profit goes back into the 10% account. This way, your money to make money keeps growing, and eventually will become quite large, and supply you with enough income to live off of, and eventually make you wealthy.

Imagine how your days will be when the stress of not having enough money are gone?

Now, back to your game. You have a budget to spend. Imagine everything you put into it, and ask yourself is it needed, and will it improve the rate of return on this investment? Sometimes something isn’t needed at all, but by spending a little extra on it, it will improve chances of return. In business, every dollar you spend is part of your investment on the product.

Lets say you got money from an investor. Angel or VC. You should never look at finances in the sense of whether or not something will fit into your budget, but is it needed for the business, and why. Depending on its effect on your budget, you should always look at alternatives. If you’re going to rent space, then you should question if you really need retail space, and how much? You should question how important the location is, because 2 miles away, you could get space for half the cost.

If you want your game to succeed, you have to have a financially viable plan to get a return on it. Learning to control your own finances is just a part of it. Anything that doesn’t help you with your goals, only takes away from it. How important are they to you?

We've got plenty of resources, right?

2009-11-23T04:00:00.000-08:00

A common practice in modern development is the nature of how we develop. We can usually only choose one of the following two choices when programming: Speed or Flexibility. As programmers, we know that our systems, and our client systems are capable of billions of operations per second, have nearly unlimited hard drive space, and billions of bytes of ram available. Hardware is cheap and easy to come by these days.

So our most natural choice is to select Flexibility for our systems. As long as we are not ridiculously wasteful with our architecture, the modern machine should be able to handle it.

Think again…

Show of hands, how many of us, on our super fast computers, with a plethora of available resources, have been slowed down by unresponsiveness; had to clear out applications from auto-loading and been disappointed with the overall performance of your entire operating system? My hand is raised.

As amazing as our machines really are, it is more amazing that we are so polluting and wasteful as programmers, that we bring these work stations to their knees.

But my software won’t have that much impact, why should I be concerned?...

Each other developer might say the same thing. Let us take a look at Microsoft Word. I just started a blank copy on my computer, started task manager and found it takes 40 megs of ram and 24 megs of virtual memory. 64 megs of ram… Remember, the most common use of this is just a glorified Text Editor. Given that Word took 8 megs of ram in 2000, lets consider that. 7 years, it went from 8 megs to 64 megs. If I round this up to an even 8 years, and put a binary jump on it, (8, 16, 32, 64) that tells us that it doubles in ram size every 2 years on average. Next, considering that Microsoft never rebuilds Word from scratch, let’s take a look at the next 8 years: (128, 256, 512, 1024) It will take 1 gig for a single instance of word to be open. 1 gig.

Naturally software will be limited by hardware, but let’s step back for a moment. Is our software really limited by our hardware? Or is it our bad coding practices? What on earth is Microsoft word doing that requires 64 megs of ram? Is it because it is so loaded with features that it needs to take up that much space? No. (I’m sure Microsoft would argue otherwise)

So what can be done to fix things? How do we make it better?

1st thing I recommend is start programming with plug-in systems. There is a plethora of free and commercial plug-in tools and source available on the internet. A quick idea is that you split menus from the plug-ins they represent. Once someone clicks on something, let that trigger the plug-in being loaded. Then if different plug-ins work together, let the plug in system load any other plug-in on first request.

If the system has a lot of resources available, have it load all the plug ins on another thread. So they are all available. If the system starts running low on resources, start killing unused ones. This is something Microsoft should start pushing in .NET. A plug-in and announcement system over the OS. Then in the control panel, the users can set modes, like Always pre-load everything, pre-load as little as possible, or variances. Of course that would mean Microsoft would have to start becoming an example of that, and I don’t really see them taking that path. (although Server 2008 is a pleasant counter statement on their part, with its far lighter footprint). Of course you can also include this part in your own settings/preferences area, and install software.

2nd thing I would recommend is start considering better code practices. Most of us don’t like repeating code. In the past, I have created loops that did something to every element in an array, while identifying 1 that it finds with a particular value. I did this with a single loop, and placed an if statement inside. While that is effective, and won’t hurt much, I could have had that if statement surround a second loop doing everything the first did, excluding the if. The result would have gotten rid of the if for every increment after it wasn’t needed. While this is a limited example, it will hopefully open your eyes to possibility’s of how and where you can improve your code. Loops are great places to start.

3rd, for Web or Network applications, consider using Cloud Architecture for supporting it. Terra Cotta is a great farm method to get rid of the need for databases.

4th, Load test your applications.

5^th, do several proof of concept tests, on areas that seem like they might be risk on resource usage. Not complete applications, but minimal comparisons of different approaches to the same need. Doing tests on each one.

6^th, If your system is complicated, and you are not sure how a user might use a section most commonly, consider putting in resource counters in a demo app, to count and report what areas, and focuses are most commonly used, then select the proof that most works with that, and change it out to improve the performance.

7^th, Stop using windows registry. There are simple ways to provide the same functionality, and the windows registry is getting huge.

8^th, use Late binding in any code that might exit prematurely.

9^th, Do code reviews, with others who can look at it with speed in mind.

10^th, Re-consider the requirements. If a small change to an obscure requirement could dramatically improve performance, bring it up. Given knowledge of the impact it could have on the performance of the finished product, the deciding parties will most likely choose faster.

11^th, if it is so complicated that you are barely getting through it, Once done, trash what you have and re-write the section. You’ll know it better this time, it will make more sense, and you will most likely be able to see better methods now that you understand it better.

It’s easy to go overboard in either direction, so all in all, keep a balance, and never forget that resources might not be as plentiful as you think.

Role of the Game Tester...

2009-11-16T04:00:00.000-08:00

The role of the game tester is arguably the most important role in the entire project, most often the most overlooked, seldom taken seriously and an overall misunderstood area of need in game creation. Typically, we have 2 types of testers, Whitebox/Clearbox and Blackbox/Opaquebox. Commonly referred to as black and white, it makes more sense to call them clear and opaque.

Opaquebox testing implies that the tester approaches testing similar to a user, installer and administrator. They don’t know what is going on under the hood. They don’t care about what language it was written in, and will typically test things in a similar fashion to how a user might use the application.

Clearbox testing implies that the tester can see inside. They can look over the code for weaknesses and possible issues. Often they write code that ties into this, and tests portions of the application that might not be perceivable to the outside world, but certainly points of problems.

Often, “Real” developers (Please smell the snark) perceive Clearbox testers as beneath them, and that they are limited in understanding, and really are just glorified users who can do a little code. The misperception is that an SDET, (Software Development Engineer in Test/Clearbox tester) knows only enough code to hook in and try to push buttons, but that they lack the ability to do anything themselves. Otherwise we would become developers.

This misperception needs to be stamped out fast. It hinders companies left and right, damaging their names in ways they don’t know. A professional SDET, should know everything it would take to build the application, and have at least 3 different approaches to duplicating it. A professional SDET can usually look at code knowing they need to look for certain things, because it is easier to accidentally program those weaknesses into projects of the particular type.

But opaque box testers also get a bad rap. And this stems from a larger problem, money. Somewhere in the company, an investor is authorizing resources in the form of money, time and people, to get a profitable application out the door. Now, there is often very important time sensitive reasons, often tying to competitor releases, end of quarter publications on the company stock or even market trends and research indicating a particular optimal time frame.

What the company, as a whole, needs to recognize is that the testers are your last line of defense for keeping clients/customers. Every time a client uses your application and it loses data, it crashes, it reacts in unexpected ways, or even just moves slowly, it makes them think negatively of you. Your shaping their next purchase with every update, release and product that goes out the door.

Its entirely possible that the competitors products are worse, but they are usually a dime a dozen. You are not the only company that offers your service. With all the issues that happened with Windows Vista, even just from a job perspective, when a tester looks for a job, and on their resume it says they tested Windows Vista, the employer might review that and pull up everything bad they recall about the product.

From both business and the tester’s perspectives, it is vital to consider the weight placed on the testers. The responsibility they have to the products. Everyone in the team needs to understand that a tester brings up the bugs because they should not be in the product. These hurt the product, the company’s image, the chances of keeping clients, and more.

Testers need to make sure that other people in the projects understand this. How important your job is. In relations to small teams creating games, testing is usually just considered beta testing. Often, the start up teams view this as an opportunity to show off their game before they feel ready to charge for it, and neglect to leave means to be contacted about bugs. Always keep that in mind, that a beta test is a group of dedicated users who are willing to try the game or application out in advance, even though it might still cause errors, in hopes that when it is released, it will work properly.

Companies should start making a change. Follow in Google’s footsteps here. Announce a time that the beta should be available. Base it on a month, not down to the day. Next, push to have the beta ready the month prior, but with some slip time. Next wait until you’ve gotten some feedback from the users before estimating the next release. If there is a huge outcry for things to be fixed, you certainly can’t release it that way.

The test role is a very serious role. It can’t be taken lightly. If anywhere in your company, this is the one place to give a lot of power to.

30 Seconds...

2009-11-09T04:00:00.000-08:00

You have 30 seconds to convince me your game is good.

[Pausing 30 seconds…]

The 30 Second Commercial is a way to define what you think will really sell your game. These are the things that will stand out the most, and the users will recognize it easily. What will your users see? How will it connect with them? Remember this when designing your game. Keep your priorities on that commercial.

So, does your game have a great plot? How will that get shown? What will you hint to entice the new players? Does your game have great visual effects? What in particular do you want to show? Anything in specific, or is this game loaded with incredible amounts of effects to pick from at random? Does your game pride itself on the vast worlds and/or rich graphics and detail? What do you want them to see? How will it look?

There are many questions, and many possibilities. For me, the 30 second commercial is the second most important thing, next to “fun”. I remember countless times of starting to design a game, and constantly thinking, “It would be cool if…” or “Yah! It’s got to do this too…” But this can distract you from what is really important about your game. What the players will really connect with.

The vast majority of the games on the market are not much more than the 30 second commercial, and they are really good at it. If your game design is 600 pages of “wouldn’t that be nice”, what parts were you going to use to get the new players in and how are you going to find the time and resources to build it all?

Games have only a short amount of time to get completed. Even if you’re a group of kids in high school, of hobbyists after work, who are devoting all your spare time to this game, there’s only a small amount you’ll actually be able to accomplish. Focus on it.

Let that 30 seconds guide you to getting the base of your game done, and then add more, once you are there. You can pick more things of “wouldn’t that be nice”, but make sure your first goals are getting it ready to at least present that 30 second commercial. I’m sure it’s a huge amount of work just to get you there.

If you are planning on pulling in investors, this 30 second commercial is vital, even while it is just a description. It is animated, it is clear; it charismatically pulls them in, like a commercial should. When you are bringing in new people, it is a quick way to get every fundamental feature across. And finally, when the pieces are getting built up, you will start to see exactly how the pieces you are building is making that commercial come to life.

Game Design Roles

2009-11-02T12:28:00.000-08:00

In any game, there are different roles that people will need to take to ensure the success of the project. While the roles themselves are only a way to organize responsibility and expertise over the different tasks, it is important for all members of the team to understand what the roles are, and how to best utilize them.

It should also be noted, that there is no requirement that the roles be assigned to individuals. I would recommend that if you don’t have a person specifically assigned to a role, and those tasks are divided up to others, that someone be assigned to be the default of that role. If a new task where to pop up, unless someone is covering that role, there won’t be anyone to assign it to immediately, which allows cracks for requirements to slip through.

Roles:

Producer

You will keep everyone on the team moving as best you can. You will identify potential weaknesses and try to repair them. Above anyone else, you should be working to make sure the team is communicating well, on the same page, and driven towards the same goal. This role, above any other should understand the different roles, tasks and needs that the project has.

· Setting Goals: Remember that goals should be attainable. This could include goals directed at research and proofs. Each goal should also have a time estimate, something to try to get people to work towards. (altered freely when needed, but have it set)
· Defining Responsibilities: Who will fill the roles? If someone has a question about something, this person should know who to ask. If the team is missing someone who is prepared or interested in taking over a particular requirement, you need to find someone who can and will.
· Setting General Tasks: You should work with other members to help them define several tasks they can work towards. Always try to provide more than 1.
· Setting Priorities: It should be your job to try to identify what is really important, and what is not.
· Pursuing Fun: The highest priority of your design, construction and release, should be things that will make people enjoy the game. The game itself should be fun to make. If your team is not having fun making the game, it’s a sign it might fall apart.
· You will be responsible for objectively looking at everything, working with people to improve their work, communicate their needs and to push to make the game as good as your team will allow.
· If there are agreements or understandings about ownership, % of the company, etc… make sure this is clear, and update them as need be based on expansion/replacements

Designer

You will be responsible for shaping the plot, game play style, handling, characters, level creation, shaping the journey and so much more. In major game development, blockbuster games often had Hollywood screen writers handling parts of this.

· Writing the Key plot, and several other interwoven plots that the game will follow
· Deciding on the medium that it will be displayed, such as 2D Side Scroller, 3D MMO, etc…
· Creating Levels that help the user move along in the plot, comfortably attain and learn to use skills, and setting up the flow and obstacles in their journey.
· Characters/Persona’s: Who are the characters, what is their story, why do we like/dislike them, how do they act, etc…
· What are the goals the protagonist will need to achieve, and how do they go about it.
· Defining what the most important needs are in the engines capabilities to support the story, characters and goals.

Developer

You will build the technology required to make this game function. You will be responsible for providing the User with the ability to comfortably and enjoyable control the game.

· You will need to build or select an existing engine to work for the game.
· You will need to educate the other roles as to what your capabilities and limitations are. They will need to know how best to work with you, and what they can expect right off the bat.
· You will need to develop proofs, or examples to demonstrate functionality for any part the game needs that you don’t already have comfortable experience in.
· You will need to define the Architecture for the program. You will find that with less experience, like 1-5 years, you will be constantly redefining the architecture as you go. The least number of changes you make will usually help prevent more bugs.
· You will be responsible for writing brief unit tests, or methods of testing portions of your code to make sure it works right.

Media

You will handle the UI Design, the mockups for possible game graphics, creating 3D models, sound effects, background music, voice acting and more. It is important to note that it can take a long time for graphics to be created, and the more resources you can get, the better.

· You will Design the user interface, and shape how the user visualizes the game, receives the information needed and the overall graphical feel of the game.
· It is important that you have mockups, and try creating a couple sample characters, backgrounds, Items and UI early in the design, for others to work with.
· You need to determine the time it takes you to create sprites, graphics, mockups, backgrounds, 3D models, and anything else your project needs. Time yourself when creating them, and what it takes to tweak it as well. You’ll often be surprised at how long it really takes to make these
· You will be responsible for making everyone aware of your abilities, which is best done through mockups, and your initial samples. When creating the samples, determine your time to build them. As you get better, you can reduce the time estimate over all, but use real numbers, even if it pushes the game out for years. Everyone needs to understand how much time and work can go into this.
· You will need to define the music, and how it makes the user feel in particular areas. Should the person be alert, emotionally attached, hopeful, curious, scared, depressed, etc… Is the mood chaotic, rhythmical, and why. You define the artistry on how the finaly material will look and feel.

Tester

You will need to test the product. Look at what was wanted, what goals where set, and look for areas that are not fun, or particularly are.

· You will need to identify key areas to test. Take a look at the goals the game is trying to produce, and how they are trying to make it fun. If this doesn’t exist, bug it.
· You will be responsible for making sure people understand the impact that a bug might have on the users as a whole. If you find it annoying, so will the users.
· You will be checking the game to make sure the feel and story flow well, and that it doesn’t stop or get significantly slowed down.
· You should create a check list of things to check for, and regularly check through them.
· You should enjoy the style of game, and make sure that things seem easy/obvious enough to pick up.

Public Relations

You are responsible for the marketing of the game, what demo groups are involved, defining a good plan for proceeding, and provide public outputs for the game as it moves along.

· Define a marketing plan, What advertising paths do similar games take? Are the games successful? What does it cost, and how long will we need to do it. What other avenues might work? Is word of mouth alone realistic?
· Setting up, updating and monitoring public forums or a blog about the game. Keeping outsiders as well as your team posted to constant updates and changes makes the game feel more alive, more attainable, and keeps people driven to complete it.
· Finding Investors, when the time is right, to help pay for marketing, servers, licensing, and other various expenses.

Most of all have fun, whatever you do.

Next Evolution of the Cloud

2009-10-26T04:00:00.000-07:00

Before you read this one, I would like to point out that I’m going to get a little out there. It discusses the direction I think technology will be taking, and the future that computing will be leading. Its hard to discuss such radical shifts without sounding like a fanatic. ;D

The cloud is an ever growing change to the future of technology. Lightly spoken, the cloud is many computers acting as one, and while such technology has been around for decades, it has not taken on such a common place in our market until now. But to really understand the future of computers, you have to understand what the current limitations are, and how to hurtle past them.

Cloud Architecture’s current nature is that of having your application duplicated across many machines, and when different users log in, they get passed to a particular machine. Essentially, the machines think they are standing alone, as the only server hosting that website, and connected to the only database providing it with information.

But in another major shift in technology, we are seeing a new birth in Thread/Parallel based programming. Making singular applications being able to spawn multiple threads and multiple processors. Similar to cloud computing, threading has been around for a while, but with the shift from singularly powerful processers to an array of processors, the direction for threading has become front row in all major applications now. Even games are starting to jump on board.

What the future will hold will be fragmented applications. Application pieces that can interact with each other over networks, to form singular cohesive units. A single application as a whole that spans unlimited machines. Each fragment containing the ability to be upgraded, replaced, called on to do things, and referenced for information.

Already, we are starting to see hints of databases becoming dinosaurs. I know, those are bold words, but think about this. To deal with databases living in a cloud world, Microsoft is putting a base limit on their database size to 1 gig per database. It makes it easier for database servers to stay synced, updated and failsafe. But that means that the database is no longer this giant source of data, but multiple sources of data spread over the network, and multiple machines.

The next logical step is to realize that with all this redundant information so easily available to the applications, why not let the applications hold on to it. Having a reference directly tied to the data is often easier and faster than having to look it up. a powerful server with 16 gigs of rams can be purchased for as little as 2000$.

Databases are tried and trusted, and it will be a long time before you start seeing the right mix of investors, architects and developers really stepping foot into this. It is sort of scary. But not to different from the internet itself. What it naturally grew into.

Long ago, on the first systems that were stably networked, there was only a couple applications that could speak to each other. You had to know specifically what you wanted, where to get it, and have the right tools. But that branched out. It grew to the point where there was no longer a limited number of applications that could be managed in a central repository of systems. Eventualy it became millions of systems, billions of IP’s and as much data as we have to give it. It grew into hundreds of systems living on their own, but yet all interacting, referencable, reacting, changing.

Applications will take a similar path. Now, the developers are comforted by the fact of knowing that another system is maintaining the data for them. That there are other means of recovering it than the applications we build. But it will shortly become a crutch to more than just our minds. Soon it will hold back the walls of progress, until more developers are willing to release their ties, and start moving to a different future.

What searches are needed, when everything already has it’s appropriate references. How will we model the data, when we can have it all as flexibly shaped as XML? I urge you all to start exploring possibilities that can extend to a database-less world, one where reference superceeds lookups. At least keep your mind open to it.

MMO Spells and AI Support...

2009-10-19T04:00:00.000-07:00

A couple weeks ago (article link), I mentioned that I had a future article that would discuss a Spell System for MMO’s, and the supporting AI for it. I first wanted to have a general AI discussion first, so there was a little supporting knowledge here. One of the problems that is faced with AI developers for MMO’s, is how to make monsters think more intelligently. Usually the AI is supposed to just “simulate” intelligence, not actually learn. Little Dumb AI’s stay the way they are, and so do the tougher ones.

I’m sure most of you have noticed, that after a little while, you learn exactly what you need to do to remove a particular type of monster in a game. But what if that kept changing? What if Mario jumped up in the air, and a Gumba decided to step back for a second, then move forward; Mario would have to smarten up as well.

The problem is that simulating intelligence, and developing a learning system are two very different things. As I mentioned in AI, one of the scariest things about AI was simply not understanding how to make it work. So what about Learning AI’s, not just reactive ones? How do we approach that? I’ll answer that in a minute. First I’m going to throw another wrench in the works.

Spell Systems...

This will apply to more than just spells, but this is a logical place to start. Spell systems usually come in one of 2 flavors. 1) They are hard coded in to the system, causing restarts if changes are required. Or 2) A separate scripting engine is implemented so spells can be changed on the fly. There is a third option, that I’m going to discuss now that is far less employed and a lot more effective.

Plug-in Spell systems. Plug-ins that can be added, removed and upgraded without needing to shut down the system. While there are plug-in systems that exist for most languages, I tend to favor Dynamic Assemblies in .NET. Where you take code in the form of a string, and it gets compiled in memory (not to a file) and tapped into your program through .NET Reflection. Visit http://www.west-wind.com/presentations/dynamicCode/DynamicCode.htm for a sizable example of it, and http://stackoverflow.com/questions/826398/is-it-possible-to-dynamically-compile-and-execute-c-code-fragments is a very simple representation. (Of course any plug-in options leave strong security holes that you need to watch out for.)

This makes it very simple to upgrade and alter spells without affecting the system as a whole. Allowing for a wider base of users to start creating possible spells. It already has a language, and you get the source code to review for hacks, prior to submitting it to your system.

Back to the A.I….

So, AI is one thing, when you have a defined set of things that can happen, and you know them all, but a whole other thing when you are talking about a system that changes and grows. How is AI supposed to deal with that? Here is a system you can use to allow A.I.’s to learn and structure themselves dynamically in the game. This isn’t a small system, but not that large either. Once built the benefits are amazing.

First, I recommend developing some sort of tap for your game, possibly using something similar to the spell plug-ins, but I recommend a networked connection, so the processing work is moved to other hardware.

Establish danger points in your game. For instance, the deepest point in caves, or the largest room of an abandoned city. This works best if you can pragmatically define them, like farthest tip of a cave. Then when Monsters are introduced to the game, they randomly seek out these places as targets. This keeps your creatures moving for you.

Next, when they reach these places, they try to establish paths to the strongest point, like A* path finding. Then, as long as no PC’s (Playable Characters Vs. Non-Playable Characters) are around, it will engage in battle with any NPC in its path. During the battle, it will monitor certain values, like Hitpoint/percentage, magic points, damage inflicted, and companions hitpoints. It will also track changes in the opponents metrics. Keep in mind that there are different AI’s running at any given time. Certain characters subscribe to different AI’s, each developing on their own, and maintaining separate recordings of metrics. Different characters subscribe with different random variations of spells, abilities, experience and difficulty levels.

So when a spell is cast, it records the affect that spell had, improving your health, your stats, your friends health, your friends stats, and how it damaged your opponent or group of opponents. Each on being recorded with averages for that spell usage. An under experienced monster might have bad experiences with a spell, and ignore it, which means that AI won’t learn as much about it.

When the AI is in battle, depending on it’s level, it will try anything at random, and then as it improves, it will choose intelligently more often. For instance, it will take a look at it’s current levels, for hit points, magic points, and try to decrease the opponents stats, while increasing its own lowest. If a particular are like hit points is dropped to a certain level, it will focus increasing it.

As the AI completes its battle, both characters are returned to default conditions, and the loser takes the previous space, intending to sit for a while. The winner will move on to the next closest space to the middle, (it should also look at the difficulty of that space compared to another adjacent space and try the easier one first)

This generates a standard flow of easier monsters first, and the strongest monsters are always found in the hardest to reach places. The real system comes down to monitoring the changes in metrics, and comparing which one will bring you to the strongest next value.

Weaker characters will roam more, being found at random by your characters. A great way to structure this is to setup Target points at safe spots in the games, like town halls of inhabited areas, monsters will be randomly drawn to it, with the possibility of taking it over, if players aren’t working to save it. Towns can be one and lost by the players. Having real lasting effects on the game. What was once a thriving metropolis could become a haunted ghosted town.

Naturally, there are a lot of angles that this AI can quickly jump towards, and a lot of tuning that may need to occur so it doesn’t become too difficult, or overrun your towns too often. But certainly adds a nice changing, growing element of your game that will allow your AI’s to learn, and automatically grow to help a game.

Starting out with AI

2009-10-12T10:01:00.000-07:00

I remember how AI appeared before I had the opportunity to really learn ways to make it work, or even, what qualified as AI. It was scary. It was one of those impressive things that you have to be a genius to build. Of course most things either seem too easy, or too complicated if we don’t know how they work. This article is a little introduction to AI, and how to apply it in games and applications.

The most basic purpose of most AI’s is to turn everything into a number. Place a value on it. Then the AI simply chooses the highest or lowest number. The trick is deciding how valuable things are. Let s pick tick tac toe for a starter. AI in tic tac toe is pretty simple. For 1, you could literally record all the possible moves, and give your AI the solution it needs to always win or tie, but never lose. But that’s no fun, and every move is pre-programmed.

To turn it into a metric, look at the paths needed to win. First move, When you place your X, where will you place it. I recommend taking a look at each space on the board, and counting out how many possible wins you can have from it. For instance, placing one in the middle gives you 4 combinations to win. And reduces any move your opponent could make down to 2 possible wins. The next opponent AI has only corners and sides to play on. By reviewing the side pieces, they realize that it would give them only 1 chance to win with it, and only reduce the opponents possibilities 3. The corner allows for the AI to have 2 possible directions to win, while the opponent also gets reduced to 2.

That was a simple suggestion. Comparing the number of possible wins a move will give you vs. your opponent. In more complicated games this gets tougher to define. Moving on to Chess for instance, where there are many possible moves, and many of them are very different. In the first ten moves alone, the total number of possible moves = 169,518,829,100,544,000,000,000,000,000. So, unlike tick tack to you really can’t just record all the possible variations.

So how do AI’s do it? It’s not reasonable for a computer to step through that many moves, and that’s only ten. And there are times where humans can identify a checkmate in 10+ moves in advance. So how on earth is that possible? It’s is more achievable when you place values on moves you make. For instance. Your opening move can have 20 possible moves. (each of the 8 pawns can move 1 or 2 spaces, and both of your knights can go forward to the right or left.) Each move can be measured for different things, like are there any openings to attack your king? Is your king directly exposed? Are any of your pieces in immediate threat? Are any of your pieces able to attack? Is your queen in jeapordy? Are any of your threatened pieces leaving an opportunity to check the king if attacked? Essentially, you write small scripts or methods that check these values, and assign threat and reward levels. For instance, you putting their king in check is a good reward level. Your king being in check is a stronger threat level . For instance, lets say that if your king has an opening to direct attack, (not in check, just an opening) it adds 100 to the threat level. If your queen is in check it adds 300 to your threat level. If your pawn can remove an opponent’s power piece, reward level is up by 250.

Once you have all your comparisons done, subtract the threat from the reward level and you get your final score. The AI will test each possible move it can immediately make and identify which of those moves have the most reward. Then it compares the next rounds. For the top 3 most valuable moves, and one random one and tries to test each follow up possibility. Adding each move to a list. Then the list is checked again for which 3 have the best score, and check again with another random one. A chess game may easily step through 100,000 moves before it’s settles on the best possible one found after that many considerations.

To add difficulty levels, each move has a random value added to it. For easy, that value could be a random from 1000 to -1000, where sometimes it would make really smart moves, but mixes it with other moves that really aren’t so great. A middle ground AI might waiver by 250 points for the end number.

Movement AI’s

Movement is another great AI. Making a path from point A to point B when there are lots of random obsticles in the way. The most common starter AI is called A* (A Star). Essentially, it takes every possible move you can make, (upwards of 8 at the beginning) and say which is the closest. Then adds that to its path, and adds every surrounding possible move, and how close those are to the goal. Then from the total list of possible moves it grabs the next closest one, until it finally gets to point B. Then, it uses only the list for the path, and uses the same AI to make its return path. Every step is taken by using numbers, and comparing for the lowest possible value.

I will mention that I only touched on some perspective ideas for how chess AI works, and there are some other problems with A* that have simple solutions regarding time. But that’s another can of worms. I primarily wanted to give you a simple perspective into the world of AI, and the hopefully give you the theoretical knowledge to get started with it.

The Future of RPG's

2009-10-05T08:04:00.000-07:00

As any of the avid game players may have noticed, the art behind RPG’s is dying. They are all about lots of quick rewards. Literally, click this, then click that and repeat 100 times. It’s only addiction is the constant state of achievement, and the fact you always feel the next is so attainable.

In a previous post, I discussed possibilities of how “Fun” can be defined in video games. While RPG’s depend on the feeling of rewards, I would ask that more RPG developers and designers start putting that as #2 or #3 on their list of things to cover. What the future holds in RPG’s is something that todays world is far more equipped to deal with. Players that can leave lasting effects on the games. In RuneScape, You mine ore from a rock, until the rock disappears. A minute later, the rock reappears. What if it didn’t. What if mining for ore literally expanded the map? What if your character could walk around somewhere, and randomly start mining. Find gold, and start a settlement. What if your military people could control X number of NPC military soldiers and take over villages, or clear out forests?

In games, the What If’s can be a painful thing to live with, as there are so many. Seriously take a look at this though. What if you could damage things like buildings and bridges. What if there was a finite amount of gold in the world. What if the monsters learned? In a later post, I’ll be discussing how to build a dynamic hard coded (interesting phrase no?) spell casting system can be linked with an effective AI that builds your world, enhances your monsters all without human interaction.

So the idea of mining literally modifying the map. First off, you need a living map, or supporting a constant state of change. Second, your map must be true 3D, not just a height map based on a black and white image. These are tough tasks, that do exist in the world, and will require some heavy proofs. Build your bridges, your houses, your mines and your mountains from stretching a single piece of ground and reshaping it. Then it will only take one modification system to handle manipulating it. Houses are simply predefined modifications. Mines can actually grow. You can knock someone’s house down. Naturally, you can give materials different strengths, indicating its more difficult to damage or work with.

Then you can create a real bounty system, and have NPC’s and PC’s hunting players who damage certain property, like the entrance to the goblin cave, or a bridge out of town, or someones house. This is one of those systems that once it’s built, it becomes putty in the hands of the rest of your programs, AI’s and players. Build real societies. But make an evolution. Don’t just write another click this, click that application. Be the next wave.

Proof of Concept

2009-10-01T07:27:00.000-07:00

In my years of experience, one of the biggest problems I've found is a disconnect between management and programmers. One that says that both sides really know what their doing. As soon as a programmer says a timeline looks good, they are telling management that they decisively know everything that needs to be done, how it will all work together, but in truth they do not. Most don't.

Most all programmers don't realize they deceive management, but its true. I'm guilty of it, everyone I know at various companies, including Microsoft does it. The problem is that we think we've built something like this before, so we know what needs to be done. While our past experience does give us clues to how things will pan out, when is the last time that a request came down from management to "rebuild" something EXACTLY like what you have done. The point there, is that all these projects may be like something that previously existed, but they always have some new, often strange, way of doing things. Some new feature, or method of control.

The problem that we face, and often blame feature creep entirely for, is once we start building something, we come to a cross roads; either we go back and rebuild part of it to work with some odd portion of the project, or we need to hack a small portion of the project to make it fit into the whole. The reason this happened, is because we are facing something we were not prepared for. Despite the fact we had an idea of how it could work, once we are here developing it, it almost always deviates from that original plan, some of it being made up as we go. If we really had our head wrapped around everything it would take when we submitted a timeline, we wouldn't be surprised by this; our original architecture would work fine for all this.

So how can we fix this? With Proof of Concept! Why yes, its the magical solution that solves every problem! ;) Or not. Proof of Concepts are the key here, but I want to emphasize that no amount of experience can fully prepare you for the future. Respect that, remember it and apply it.

To really understand what is involved in the project, start stepping through the requirements, and existing design. Create a list starting with the most basic abilities to be used. Even if you've already know them really well. Then start adding on the layers. "Show a text box" > "Limit the amount of character" > "validate they are in a phone number format" > "Check if the number exists in the database" > "geocode the region for the number" etc... And as you start to look at this list, find anything in it that you have not built before, and go build it. For instance, Validating a phone number format, when you start considering that, you have to ask yourself what formats are acceptable. Well, there are many, and other countries. So, the requirements either need to list what type of phone number's are acceptable, or you need to accept all of them. That's immediate feed back on the requirements, and if you waited until you hit that point to start asking these questions, you may already have database options limiting against what you need, and other parts of the project that already work with one style of phone numbers. You wouldn't know this until you actually address it. and by then, having to go back and change everything leaves a lot more openings for errors to occur.

So, always outline a list of what approaches you need to use in the project, including how things interact. This will also help for feature creep. When someone says, "now I want you to add this", you can break it down, and see if you have any proofs existing to cover it all. Chances are, that you do not. And chances are, it might require changes to the architecture or hacks to make it fit. This makes the things you do much more clear.

Argument, "Management would never let us spend that much time defining something out". You are possibly correct, but that is only because of the first sentence about the disconnect between management and programmers, followed by the idea that they don't know what they are doing. (given the paragraphs that followed it would be easy to assume I was leaving management blameless. :) )

By demonstrating to management that using proofs will make timelines far more accurate before the project even begins, is a huge value. How many projects have you been on where everything was on time, and under budget? While a few might get through like that, in general, that is not how it works. Things get pushed out with bugs, pushed out late, or dropped altogether. Often a combination of all three.

Yes, this will take more time up front. but, as time goes on, and this practice is adhered to, everyone will start gathering more proofs, more practice, and the proof of concept stage will get smaller and smaller. (depending on what is being requested) Eventually, the companies become very streamlined, and the proofs help shape exactly what areas the company has real experience in.

Also, a proof can be used as a reference to say, "it can work like this", or "here is another option to try for it" Also, proofs help shape additional questions, like "What phone number formats?" and "What security levels?"

Again, I don't expect every company to just jump up and start acting on this. but do take a serious look. Watch when projects fail. Watch when those cross roads reach you. Once you start keeping track of it, it becomes more clear, and you'll see why this practice, or something similar is absolutely necessary in the real world.

Selecting a College

2009-06-01T19:01:00.000-07:00

Today, I'm focusing on how to select a school. While I'll focus on Technology, this really applies to many topics. When I find a school that has the class coverage I want, I then seek information on the key instructors.

I want two things in my instructors, that they do practice what they preach, and that they view what they do as a form of art. Technology and art forms are not usually synonymous, but I'll get to that.

First, I want to talk about practicing what you preach. I don't want a teacher that studies and does a few practices on their own, but isn't expected to complete practical work. There are a hundred ideal ways to build an application, but many of them are not practical with modern management. Projects start with great aims, but change significantly and often. Not many isolated teachers recognize that in clear enough terms to prepare their students for it.

An easy example of the difference between knowing the path, and walking it, is to look at learning a new language. There are not many teachers or books you can learn from that once you've mastered their courses, you can travel to the country of origin and speak the language, without people knowing that this is a 2nd language for you. It stands out. This is the same with programming. You step out of college, get your first job, and suffice it to say, there are plenty of things you still needed to learn, like we don't actually do that here, or that's not really practical given the time constraints, or don't tell management you can do this in 3 weeks when you haven't actually built one before.

An instructor who has to work in a practical environment is something I would target. This is usually easy to figure out, as most instructors will usually have a page describing them selves, and what they do. If they have a job or run a company, aside from teaching, they'll probably list it.

The 2nd target I seek, is an instructor who really sees the art of what they do. This is a little harder to learn about the teacher, but it is really valuable to have. Some one who doesn't understand art, sees what a picture looks like. But an artist can read between the lines. They can see the feeling that was intended when it was written. This is not limited to the commonly accepted artistic fields.

This is really about reading between the lines. What does something mean that it does not clearly say? Someone might look at the Mona Lisa, and see a painting of a woman, while others who look deeper, will read subtle expressions of thought that show up through it, along with many other things.

This translates to programming as well, because the code is similar to art. If you look at it, it tells you what the developer told the computer to do, but if you read between the lines, you'll see why. Many developers don't use much in the way of style guides, and pretty much live off of the commonly out-dated Hungarian notation.

The problem with this lies in the fact that when you don't commit to a stronger style guide, the styles that do show up change from line to line, sometimes even multiple times in the same line.

In the real world, when some one programs like this, and another developer is brought in to take over, or restart the project, they often feel it would be a better idea to rebuild the entire program from scratch. It doesn't flow well, definitions aren't clear and you usually have to dig through layers of code to figure out what part of it does.

Someone who has experienced this, experienced it and grown from it, will be able to pass that on in classes, otherwise they are dooming all of their students to suffer the same fate, and pass the same problems through the work place.

If possible, find some source code, (often examples made by the teacher, or pet projects they have public on the Internet) and ask a friend who has experience to read through it, and tell you what they think of the code. A more inexperienced friend might call the code overly formatted, but typically it will be easy to read, understand, and express itself clearly.

For those of you involved in programming, who commonly find yourself wanting to rebuild your own projects after only a short while, because you've learned a new trick, or want to re-organize it, I suggest you look up Microsoft's API Design Guideline. There's a digest floating around that sums it up quite nicely.

Educational Compass for Teaching

2009-05-08T09:55:00.000-07:00

When I first started teaching at colleges, the hardest part for me was the Syllabus. I was supposed to define what I was going to teach, and cover, to a certain level of granularity. This is typically a problem for me, because I don't teach the class, I let the students decide the Curriculum.

I don't read from manuals, prepare slide shows, or have a check list of every facet I speak about. Each morning, I create a list of keywords I'm going to cover for that day. as I go through the class, I take a look back at that to make sure I'm getting everything.

I make up the list in the morning, because I don't know what I'm going to do with the class. I have a vague idea of the direction, but I ask the class what they want to do (within boundaries). I need to make sure several key topics are covered, but the farther into the class, the less direction I provide, and the more I use the students as a compass, guiding me to what to teach.

A downside I face, as others might see it, is that I didn't have the code prepared that I use as examples. That means I could be showing them an error. OH NO!!! AN ERROR!??? How are students going to learn that mistakes are ok, and that we can learn from them, if the teachers hide from it themselves. I embrace the mistakes, and use them as learning exercises for the class.

In programming in particular, when a mistake happens in the code, the environment gives you clues as to what went wrong. That is one of the biggest learning tools. Especially these days, when it says things like, "You can't use a number here, try using a true or false" (close enough) It works great.

I will admit that you really have to know what your doing to teach like this, but if your going to teach it, it only makes sense that you know it that well. You should be able to write a small book on it if need be.

My students tend to have a lot of fun, enjoy them selves, and learn a lot in the process. I recommend any other teacher try to look for ways to allow mistakes to show up, and make it work for your classes. I recommend, if your comfortable with it, to try teaching with nothing more than a brief list of keywords to target, and teach according to what the students point towards the most.

Define "Fun"...

2009-04-29T16:45:00.000-07:00

One of the first hurtles anyone has to get through in game development is figuring out a definition for "Fun". Quite often, the initial keywords/phrases a designer may use when first conceiving a game would be "Interesting", "Challenging" and "Lots to do". But the one keyword they should be focusing on is "Fun".

So what is fun? : Fun is why people play your game. It is what gets them involved. It is why they tell others. And, it is why they keep coming back for more. Granted, fun can be challenging, interesting and give you lots to do, but the word challenging can describe wrecking your bike, and having to walk it home 2 miles in the rain. NOT FUN. Challenging yes, but not fun. All to often a game designer will get caught up figuring out how to challenge, when you should always first questions yourself, would the players enjoy this?

First, look at some of the games you play, the games you are most interested in. Don't consider the technical details of it, but start asking yourself "Why do I enjoy this?", and "What makes me keep coming back for more?", and naturally, "Why would I pay money for this?". Make a list of things that you think really tie you too it. Be honest; don't just put things that tie directly back to your ideas, but think through what really makes you want to keep playing it. Order these by what you think is most important.

Now, look at your existing designs, and look for where it addresses any of these. chances are, it probably doesn't address any of it, and probably not things at the top of the list.

Now that you have a list of what you really enjoy about a similar game, Start going through your existing design, or start a new one, and everything you add, or have added, ask yourself does it help with the list, and how valuable is it. For instance, if your list is 20 items long, number them 1-20, then each requirement laid out in your game design should get a number corresponding to which item on the list it covers. If it is not on the list, put an X next to it. This right now, is a really important make or break time; don't look at your design trying to defend it, but look at it like its too big, and you need to simplify it.

Now, take a look through your design, and see what stacks up. You'll probably find that some of the lower end items have a lot of hits, while your top 3-5 have very few. This is bad. The best reasons for playing your game are being ignored, while these little things are taking over. They are consuming your design time, and certainly will reek havoc on programming development and graphics time. Remember that every requirement you add, can easily add a week to your projects timeline.

Now, I don't expect anyone to do exactly what I suggested. This is intended to give you some ideas, but the most important thing to get from this is that you DO need to figure out what is fun, and focus on that. Anything else is extra.

McEducation...

2009-04-29T16:02:00.001-07:00

Education is, by far, one of the most important factors in any ones life. It helps take the luck out of success, and in general, improves the quality of their lives and everyone around them. But that's not necessarily true any more.

Public education has significantly changed over the years. What is a diploma worth? While our kids take classes on Economics, History, Calculus and Psychology, a high school diploma has dropped to the income of a happy meal.

In my years of teaching, I've seen 7th graders learn binary encryption routines and apply it within a 30 minute period. I've also seen people graduate high school that had no practical work skills.

I've seen documentaries, and witnessed first hand what our public education system is, a backup. It is a backup for a real education. It is a backup when there are no other options available. When the money starts disappearing, what's the places companies like to pull money from? Luxuries and redundancies.

The public education system has been a mirror of our country's economic and health status. More and more physical education and exercise was removed, while our country's obesity was on the rise. The No Child Left Behind act gets started about the same time that Walmart starts taking over. We see dropping educational resources, and a rising percentage of jobs that don't provide enough to live on.

So I put this into every ones hands, Education is not something the government is capable of handling any more. (Please understand, I know there are anomalies in the system. Teachers, programs, leaders and others that do great things; but this is usually against the grain, and certainly not the status quo.) Education, if you want it done right, needs to be from experienced people who know how to apply it in the real world.

A Happy Meal is (to me) an epitome of unhealthy choices both financially and for a child's health. It is selected because parents don't know better, or don't have the option of something better. (for time, for knowledge of cooking, for finances)

You can feel the difference of a school that hires teachers to work there, and a school that finds teachers who have a passion for what they do. To one, its just a job, in a system that wears them down. To the other, they can show exactly how things are done, what they can really do with them.

For most of us, we have had teachers that really were impassioned about what they taught, and at the same time, experienced the contrast of a teacher who is just looking from one paycheck to the next. Ask them, how do I ever apply this to real life. One will show you, another will tell you to open your book to page 5.

Don't take your's or your kids education lightly. And kids, don't settle for poor education. Every reduction in the quality of your education, is a reduction in your future quality of life. If you don't leave a class room feeling excited about it's future, and yours, then you need to change something.

I recommend looking into charter schools, having talks with teachers, and ask them about their personal interest and history with their teaching subject. What they do for fun, with it. A good math teacher will usually like puzzles, and finding tricks and teazers for the kids. A good english teacher will enjoy novels, and seek ways to get the kids excited about stories.

Any teacher can require home work, but only a good one can make it exciting.

Intro

2008-12-01T10:53:00.000-08:00

This blog is dedicated to announcements and information from Learn Build Play, which is dedicated to learning through game development.