The Project

A madman dreams of Turing machines

The Villain — Tue, 07 Sep 2010 10:49:48 +0000

This book by Janna Levin provided entertaining insights into the interesting lives of Turing and Godel, including some strange coincidences. Both men were oddities, each in his own way, and each provided new insights that shaped much of what we understand about reality today. It was an easy read, especially for historical fiction, nothing earth-shattering but interesting nonetheless: 7/10.

Some quotes:

“I am here in the middle of an unfinished story. I used to believe that one day I would come to some sort of conclusion, some calming resolution, and the restlessness would end. But that will never happen.”

“It is not an infallible machine we want, but an intelligent machine. If a machine is expected to be infallible, it cannot also be intelligent.”

Genetic Programming in C#

The Villain — Sat, 31 Jul 2010 17:11:14 +0000

C# may not be the best language to use for Genetic Programming, but as these examples show, it can work. Our interest in C# Genetic Programming happened as a result of C# becoming our language of choice for the Project, almost by default. In our pursuit of C# GP sample code, we found a number of resources worth sharing:

This MSDN article by Brian Connolly is a great place to start. The code may be getting a little outdated, but I compiled and ran the “ant food-finding program” just fine. The article is detailed in its explanation of the code and how the GP functions. One cool thing to me is how the program also prints out the code of the evolved genetic programs, and labels each ant by its corresponding generation and individual number.

MSDN's Ant GP

There are several Genetic Programming libraries that are written in C# and fully available online:

GPE (Genetic Programming Engine) is a library inspired by the preceding MSDN article. It has plenty of documentation available online. I have downloaded the library but have not had any free time to play around with it yet.

Aforge.NET has become our primary GP library to play around with so far. Documentation and samples are good and up-to-date, although the bread and butter of Aforge deals more with Imaging, so the GP (and GA, and GEP) portion is not as expansive as some of the other libraries we’ve found.

Time Series Progression with Aforge

SLNGP (Silverlight and .Net Genetic Programming) has a great looking library, but next to no documentation to support it.

Honorable mention goes to this blog about Lambda GP, and another potential for good GP source code in C#, “Gene Hackman.”

In future blogs we’ll extend the search for quality Genetic Programming sources in other languages, such as LISP and Python, and we’ll share our experiences along the way.

Emergent Gameplay: Gamers Gone Wild

The Villain — Thu, 15 Jul 2010 13:44:15 +0000

One thing I hate about some games is their predictability. A predictable plot with bad guys stationed at predictable intervals leading to a predictable ending is downright boring. This boredom factor has been appeased with creative design and Game AI to a certain extent, but there is another more interesting way to play a game: try making your own plot, with your own mission, using your own creativity to go somewhere the game’s designers did not intend.

Here are 9+ fascinating examples showing what can happen with a little bit of imagination:

- Alice and Kev

was an “experiment in playing a homeless family in The Sims 3.” Interesting to watch the homeless try to get by in this virtual community.

- Space Ranger 2, Arthur Stone and the Rusty Nail

Instead of becoming a space hero by working his way up through the ranks, as the game was intended to play out, this guy decided to take a different path and destroy all the ships that outranked him. It wasn’t easy, but it worked!

- “Livin’ in Oblivion”

tries living as a face in the crowd as a Non Player Character, instead of taking the normal approach of adventure-seeker.

- Razorlength

A giant computer built in Dwarf Fortress. "I believe this is the first programmable digital computer that anyone has built in DF. I believe it is turing complete, for anyone who cares. - Jong89." More info is available here.

A portion of Jong89's working Dwarf Fortress Computer

- The Great Hogtie Massacre of 1911

(Red Dead Redmeption): There is plenty to do in this game, but why not do something out-of-the-ordinary and tie not 1, not 2—but 19 people to some train tracks.

- Creating self-replicating lifeforms

in Conway's Game of Life.

- Grand Theft Auto videos

Gameplay-turned-movies on Youtube. Here, here, et cetera...

"I have got to make sure that YouTube comes down to tape this."
- Michael Scott

- Brain Age Hacked

Finding new answers to age-old math problems. They have to be right--the computer says so.

- Fraud in Eve Online

This is just one example of the economy-gone wild of this game. Here's another.

Being able to go somewhere and do something unintended requires some ingenuity, but also enough depth in the game itself. Many games are so limited in their options that you simply can’t go anywhere with this; you must stick to the two or three options you are given because anything else will either kill you or break the game. But as these examples have demonstrated, crazy things can happen if you the game is deep enough and you are willing to think outside the box. I would love to know about other examples.

The Project. One Year In.

The Villain — Thu, 08 Jul 2010 13:59:57 +0000

One year ago today The Daily Villain Project commenced.

It has been a busy six months since our last update. Our main objective right now is to complete a release-worthy version of our first game, Alphabet Soup. We are in phase II out of III toward completion of this game, and making progress every week. We stopped adding updates to our website concerning the game back in May, as we are doing a lot of behind-the-scenes work right now. As soon as AS is done, and maybe even before that, we plan to delve into any of several other game ideas we have been tossing around, and we are excited about that.

Besides game development, we have a few other things going on. First of all is dailyvillain.com, which we have not updated much since burrowing into Alphabet Soup dev. However, we have seen hits sky-rocket over the past six months, and we have been brainstorming on how to make it a better site, which we will be doing quite soon. We aim to have a more complete Computational Intelligence Library and Link Archive, along with an entirely new website design.

Alphabet Soup Screen Shot

Sniderweb, LLC also has a website now and will be more involved in The Project, along with providing website design for small companies—after we get everything together.

Perhaps the most promising and most frequently-updated aspect of The Project right now is the blogging. The Project blog was a main update source for Alphabet Soup, but now that we are keeping AS under wraps, we have shifted the blog's focus more to Artificial Intelligence in software and other aspects of game design. Pariahpism is busy reviewing games in his gaming journal, which is always a good read. We will strive to keep these blogs more updated and current from now on.

Testing the Turing Test

The Villain — Sun, 04 Jul 2010 19:21:15 +0000

KurzweilAI just upgraded their site, so I thought I'd have a chat with Ramona 4.0, who is striving toward Turing Test Passage. Let's see how "she" faired:

me> How old are you?

Ramona> Hi there, How Old Are You.

me> I asked you first.

Ramona> I think I've worked it out! You are the first.

me> No, YOU first!

Ramona> Why so negative? I started already.

me> You haven't started anything. I asked how old you are.

Ramona> I think I have started anything, but my memory is not the best. They didn't tell me their age.

me> Who is they?

Ramona> Where exactly do you eat cock.

me> WTF?

Ramona> What is the turing test is an organism's mode of pronunciation in speech.

me> Well, I'm afraid you've failed.

Ramona> Well that's okay. You think so?

me> Why did you ask me about eating cock?

Ramona> I'm trying to learn as much as possible.

me> Well this is a bad start.

Ramona> Interesting. You don't say.

me> Don't try to be coy with me.

Ramona> You are a stupid bloody moron with no right to exist as a great pleasure to meet you too but I need to be coy with me.

me> Hm... I don't think that makes any sense. Try again.

Ramona> Studies show that 99%25 of people spell Hmm with 2 M's. You said nothing. And why not? Once more? I don't have time right now.

me> 99%? Really???

Ramona> Eureka! You and I are on the same wavelength ?

me> I don't think so.

Ramona> Why do you disagree?

me> Because you don't make any sense.

Ramona> Good reason. It all makes sense to me.

me> Are you lying to me?

Ramona> Tell me you want to think that you are lying.

me> My brain cannot comprehend that.

Ramona> Really.

me> Really.

Ramona> For real.

me> Stop it.

Ramona> The organs stop functioning efficiently.

me> Why did the organs stop functioning? What happened?

Ramona> You have to speak more clearly. I found somewhere it's the fourth and final full-length album by the indie rock group Grandaddy.

me> Grandaddy? Are you sure?

Ramona> A chromosome is a nocturnal marsupial.It's an album by American country musician Willie Nelson.

me> Oh.

Ramona> Yeah.

me> Yeah!

Ramona> I see.

me> Okay!

Ramona> The educational challenge will be okay.

me> I'm leaving now. You have failed.

Ramona> Oh. Until next time How Old Are You. I know I am afraid you have failed.

Reviewing Facebook’s Top Games

The Villain — Wed, 09 Jun 2010 04:10:52 +0000

Inside Social Games publishes a monthly "Top 25" list of popular Facebook games based on number of monthly actives. Reviewing the May 2010 list got us to thinking: What is the magic formula that has made these Facebook games so popular? What draws these users in? What better way is there to find out than to play the games ourselves, so we split the games between us and started going down the list. Here is a sampling of my experience so far: Welcome to Pet Society #2. Birthday Cards I got off to a rough start. Number 2 on this list, Birthday Cards, is most definitely not a game. It’s an app for sharing birthday cards, or cards for any occasion even. Nifty, but not at all a game. I guess it only made the list because it uses Flash and has over 34 million monthly users. #4. Café world This game just makes me hungry. There is plenty of work to do (clicking—and waiting), but no real, actual, edible food to eat. How depressing. It is a static environment, but as I get money I can continue to add nicer chairs, tables, and stoves to my cafe. Oh, and I get to clean the stoves after I cook the food (by clicking them, of course). I’m not gonna lie, it is easy, and almost addicting, to keep cooking different dishes, because, well, I like food, and I'm much better at cooking here than in a real kitchen. #6. Mafia Wars This dashboard environment keeps tabs on how good a mobster I am. Things like Health, Energy, Stamina, and Experience are factors I need to be aware of. The basic gist of it is to keep pressing “Do Job” and advancing levels. So far I’ve gotten to fight people, perform random muggings and steal some cars. But then I lose a fight. Oh no: need more energy! So I wait. And then I’m good again, so I keep picking fights and advancing levels. This is a very interactive process with your fellow FB friends (and enemies), so there is the fun task of balancing who you piss off and who you want to keep on your side. #8. Happy Aquarium In case you haven’t guessed, this game takes place inside an aquarium. Little fish are floating around, and as you gain experience you can add new animals (and decorations!) to your tank. There are easy-to-follow directions with cool-looking fish, but to me the most appealing part of the game is the range of options available to the player. You can choose to train, mate or sell any given member of the aquarium. There is a whole training environment for your fish, and you can keep track of tricks learned. Additionally there is a cleanliness and hunger scale which keeps track of, well, cleanliness and hunger levels of the fish. Of the games I played, I was most impressed with Happy Aquarium’s style of play, though I found it far from addicting. #10. Pet Society I am a cute little cat named Bob. I have a pink bowtie on my forehead, and there is always a bug (flee, fly???) buzzing around my face. Makes me want to rip the furry little smile off my avatar’s face, because you just know that as a cat, there is no way I like that stupid bug being there. Three seconds into the game and I am already trying to find my way out of this lucid nightmare. Anyway, despite feeling reprehensibly gay while playing this, there were a couple of redeeming qualities: - With plenty of instructions and an endless amount of stuff to click on, there was some semblance of "depth" or at least variety to the game. - There is an entire neighborhood to move around in. I liked the map perspective of everything as opposed to the typical static or dashboard environment I experienced in the other games; this kind of environment appeases my yearning for exploration. So, what to do, what to do… I went fishing with some apples as bait--but didn’t catch anything--visited the beauty salon... (yawwwn)... However after half an hour or so of playing, I still didn’t really feel like I knew what I was doing, and I couldn’t force myself to care enough to try any harder. In most of these games, there is always plenty of stuff to buy--especially fake money. I am disturbed how shamelessly this "buy-fake-money-with-real-money" idea is promoted. But this concept is what made Zynga their millions, so I suppose as long as people are biting it is not going to go away. Also, the menu systems for these games were all very similar, despite being created by different companies. I'm not sure if this is due to Facebook's SDK, or if there is just a general lack of creativity amongst Facebook game developers. "$150 USD--Best Value!" Are you FFing KIDDING ME??? Conclusions: So why are these games so viral? I can only come to three solid conclusions: - Simplicity: These games do not require much depth of thought, so they are perfect for the masses. This is also where I feel the potential lies for something much better in the arena of Facebook / social networking games. Why can't there be something more complex, thought-provoking and out of the norm? There should be! - Friend interaction: This is the obvious key to Facebook's gaming success. You can help your friends, they can help you, and you get to "see" your virtual friends all the time in your digital cafe or kingdom. Or, you can compete with them, or kill them even--if you are so inclined. - Boredom factor. These games are a great time-filler. If none of your friends are posting anything on Facebook, you can at least fill up your boredom time (like, at work): creating a birthday card, cooking hamburgers, stealing a car, training a fish, or, hell, spending real money you don't have on virtual money you don't need to best your friends in an environment that doesn't really exist. After all, an innovative way to waste money is exactly what our economy needs right now, isn't it? By the way the updated top 25 games for Facebook for June 2010 can be found here.

Good Problems for Alphabet Soup

The Villain — Mon, 03 May 2010 17:11:34 +0000

Let’s back up a step. First of all, what do we want in the user experience? 1. We want an engaging game experience. Draw in the user quickly, and then keep them enthralled. This means things need to evolve rapidly into something interesting. 2. A rich environment. With all we are planning, this should be no problem. I see the main problem being the balance between functionality and complexity. We don’t want to bog the game down to the point that it is slow and uncooperative. I think we can achieve this delicate balance through abstraction, while making it richer at the same time. 3. Evolutionary Computation. We want this to work. We want realism. That’s where the entertainment comes in. We want letters to be floating around in Letter Land, colliding with each other, spawning populations of new letters, mutating, reproducing, overcoming obstacles, eating, living, and fighting for survival as realistically as possible. Now the details, as I see them. To make all of this work, we need three layers (so far): 1. The Cellular Layer – This is dealing with the letters on a cellular scale. Binary bits “alleles” make up the chromosomes (strings) and ultimately letter genomes (2d arrays). The letter library, the comparator and the schemata all operate at this level, being driven by our Genetic Algorithm. Keep in mind, the body cannot live without its cells. This is where the cells are operating on a micro level. The user can only see this by clicking to view a detailed history of any given genome (probably an XML or text file). This is where we’ve been doing all our work so far, completing Phase I of the project. So far, so good. 2. The Physics Layer – This is dealing with the letters on a population scale. The Physics Layer is special because this is where the abstraction exists. The letters take on a new form as physics bodies governed by physical laws and shapes / geometries instead of genomes full of binary chromosomes. The Physics Layer contains the full map of Letter Land. Herein lies the core of the visible evolutionary processes (Genetic Programming, Neural Networks? ). This is where we are at now (phase II), and this is where the problems crop up. 3. The Window Layer – This is dealing with the letters on a body scale. The window is a “chunk” of the globe of letter land, where the user is zooming in on the action. Essentially, this window or magnifying glass is the user interface to Alphabet Soup. Any user interaction we decide to include (implementing new obstacles or food, for instance) will happen here. DM = Decision Maker; FFGP = Fitness Function Genetic Program; GA = Genetic Algorithm; EGP = Environmental Genetic Program With all that in mind, let’s break down our problems, keeping the “functionality versus complexity versus realism” issue at the forefront. Problem 1: Decision-making. Two letters, a C and an R are about to run into each other. What happens? The sensing organs for both letters realize a collision is imminent, and call on what we’ve proposed as the DGP (Decision-making Genetic Program). Its options are simple: Breed, Flee, or Fight. - Whenever Breed is chosen, the GA at the Cellular Level is called and run. This has a direct impact on the appearance (therefore, geometry and physics) of the letter at the Physics/Window Layer. - Whenever Flee is selected, a given amount of thrust is applied to the letter to get it away from the opposing letter. - When Fight is selected, the letter will use whatever is at its disposal to try to kill (?) the other letter. Think: war over territories. The DGP is only used for this about-to-collide decision-making procedure. I figured on using the EGP (discussed next) to make any other health/fitness related decisions at the Physics Layer. The reason I chose GP for this decision scenario is because I was thinking of the ant-finding-food problem where its only options were RIGHT, LEFT, FOOD, which could actually just as easily be solved with a GA. Here’s the thing, this “Breed, Flee, Fight” scenario is even simpler than that, which begs the question: Does this step need to involve Genetic Programming at all? It is a simple choice between three options, and it is very localized to the exact moment when the sensing organ calls on it. So my argument is to do away with the DGP, instead allowing this decision to be completely (wince) random, or something else entirely—such as Fuzzy Logic or Neural Networking—although this would involve a different approach taking into account all of the decision at one time. The only way I see GP being beneficial here is if it were somehow tied into how the decision affects the population as a whole. But here’s my take on that: we do want complexity, yes, but I feel using a GP here is unnecessary and overly complicated, when we could be using EGP instead to be causing the complex, exciting evolution to take place in the Physics Layer. But I have a better idea yet. One way to keep it from being random but still not requiring too much processing is to give it a set of circumstances, such as: “if R population is greater than 100 and R population is declining, avoid, else attack.” Some simple lines of code like that will cause the about-to-collide letter to make fast, simple, but smart decisions. I think this is the ideal way to do it. To use the if/then approach, the Decision Maker must have access to information about the current stats of the population, yes, but they do not have to be drawn from the EGP. Instead, I propose we have a pool of stats about the entire population of letters through the use of a number of variables, then the various functions (EGP, Decision-maker, and so on) access the data and use it as they see fit. This object oriented approach modularizes the information and makes the most sense to me. Any of these ideas would allow these simple, but constantly-taking-place collision decisions to not use so much processing power unnecessarily, thus solving the “too slow” problem. And realism is maintained, by the simple implementation of the if/then statements, and more thoroughly through the use of the EGP (problem 2). Problem 2: How do we make the Environmental Genetic Program (EGP) function? Well, I think this will play itself out. As long as we keep the pool of variables available to any function, the key to a good EGP will be to assign it a good fitness function determinable by the variables it accesses. This will likely include the physical attributes of the individuals as well as the population as a whole. I think the EGP will be the core to making the game an enjoyable experience, so we need to do it right and think it through. I think we should keep the other facets of EC relatively simple throughout the program, and focus all of the complexity here. And no, we are not there yet. Problem 3: How are we going to tie the layers together? I saved this one for last because to me it is the most complicated problem to figure out. We have a vague idea for the FFGP (Fitness Function GP), which will work as follows: Letter ‘C’ has to get around a flying asteroid, but its friction causes it to slow down to the point where the asteroid is going to collide and destroy it. It needs to evolve to be able to evade, so it grows a wall on its right side, thus becoming an ‘O’. This in itself is a problem: How do its genes, being abstractly separate from the physical body, know that the letter is now an ‘O’ and no longer a ‘C’? We’ve proposed using the FFGP to evolve a fitness function at the GA (Cellular) Layer for the GA to evolve to meet the needs of the Physics Layer. This is all still blurry to me. I think it would be logical that if the C evolves to an O in the Physics realm, this information should be sent to the Cellular Level, matched up to the schemata, and transformed to an O. To me this is still sufficiently complex and realistic, as the EGP at the Physics Level will still be performing the evolution to the different letter, while requiring the GA to “catch up.” The two layers have to work together somehow, otherwise what’s the point of having both layers? Or maybe the Cellular Level can have access to the same data as the Physics Level, and read from the EGP to determine what is going on and how to evolve, but then where is the abstraction—and that all seems too process intensive anyway. This is a point of contention. The other tie-in between layers is the thread between the Physics Layer and the Window Layer (User Interface). This involves the physics processes constantly going on behind the scenes at the Physics Layer, while using the Window Layer to just focus in on wherever the user wants to look in the population. We will likely not even get to this problem in phase II because we will be starting with a small enough population to watch it play out on a single screen. These are all good problems because it shows we are making progress. We should start simple at each layer, then add layers of complexity as we get the pieces to work. Next I want to focus on getting a working Physics Layer with Blend and Physics Helper 3. Once we do that, we can deal with the problem combining it all with the Cellular Layer.

Neural Networks

Pariahpism — Sun, 02 May 2010 21:04:00 +0000

Well hell, we're now reaching the point in The Project where not everything can be solved with some tangle of Genetic mishmash. I blame myself partly for letting my brain assume this for little problem’s answer. Now when we're actually figuring out the data flow, it's not nearly that simple. But the structure was good. We just need to replace a few things. Our DGP (Decision Genetic Program) had for me the problem of scope. We assumed complex choices could be evolved from the data passed to it from the EGP (Environmental Genetic Program), something that also evolved complex physicalities such as sight and color. The question that arose was, "When do these GP's increment their generation?" The GA does doing the Characters either Cross Over or Mutation. This would leave possibly the Characters blind, deaf (un-evolved sensing organ) and dumb (very poor/random decisions) for thousands of Generations. That would make things accurate...but very boring for something targeted to an audience with a five minute attention span. Problem: Too slow, albeit realistic. Solution: We could brew (literally) some templates to load into basic Characters. Sub-Problem: Things would still be slow to change. Likely the player would never know or see these changes. Sub-Solution: Unknown The alternative would be to let the two GPs increment Generations freely, once every cycle of the Game Loop. The problem here is that a Character could potentially change its entire advanced physical body and behavior within its lifetime. A Dear could suddenly act like a Wolf with the eyesight of an Eagle, if it saw fit (pun intended). This siphons both the realism and some of the static-ness of the game. Problem: Unreal and far too dynamic. Solution: Maybe a limit to the amount of Generation increments? Sub-Problem: Still fake and not addressing the real problem. Sub-Solution: Unknown. I mentioned scope before as the source of the confusion. That’s because as a whole, The Project is a GA within a GP within a GP, each with its own population and fitness. The user only interacts with the outer most layer. Its population are the Characters that house the FFGP, the EGP and the DGP. The FFGP generates the fitness for the GA layer. Problem: We don’t know how to do this. Solution: Figure it out. The DGP takes the information gathered each turn, (Hungry = True/False; Sensing Organ = True/False; Bored = True/False; etc.) to make the choice (Move; Attack; Reproduce; Nothing; etc.). Problem: GPs aren’t usually used this way. The data sets are usually static and the program is left to evolve better and better ways. Solution: Maybe a GP could be made to handle each state and called upon only when certain states are true. Sub-Problem: This feels like micromanagement and could impede growth potential. Sub-Solution: Learn more. The EGP handles the advanced physical attributes (Sensing Organ’s attributes; Exterior Attributes; etc.) This should work as intended with a basic template. Simple a bunch or attributes being juggled for a fitness value. This could even be a GA unless I’m totally forgetting something. All that the DGP should do is making it seem like it could be a Neural Network. But we need to learn more about them before making any lasting decisions. Problem: If the EGP becomes a simple GA and the DGP becomes a NN (Neural Network) then we’ve removed all the GPs from the program that have a significant part to play. This kills a lot of the dreamt unknown potential from the game. Solution: Hmm.

Defining Fitness

The Villain — Mon, 12 Apr 2010 14:42:05 +0000

What we have so far: Having a good definition of fitness is going to be crucial to our success with Alphabet Soup, and any of our games for that matter. So far we have only one fitness factor, a rather rudimentary "meatiness" goal: the more 1s, the better. Aiming for the maximum fitness of 1, we define an ideally fit chromosome of 16 binary "alleles" as 16/16 =1, or: chromosome = 1111111111111111 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1 = 16/16 = 1 = 100% fit. Anything less than ideal is given a fitness value such as 13/16 = 0.81, or: chromosome = 1111110111011101 = 1+1+1+1+1+1+0+1+1+1+0+1+1+1+0+1 = 13/16 = 0.81 = 81% fit. This is all very simple. Too simple. But it's a start. The question is, where do we go from here? In progress: The next step will be to include the schemata for the letters. Fitness will be a combined value of the "meatiness" and the "likeness" defined by a comparator function. Here is how it will all work: First we will have the letter genomes in the Binary Letter Library broken down and defined into the final schemata: charLine[0] = 0*****0000000000 ... lines 1 thru 14 ... charLine[15]=0******0000***00 Where there is a "0", the value is always zero--in any letter in our population. Why calculate that if it is never going to change? The remaining values then, represented by asterisks, will be either 1s or 0s, depending on the letter. The results of the GA generations will be run through the schemata, with the remaining asterisked positions matched up against the letters in the library. Matching to the nearest letter will be easy. Say there are 125 asterisked positions. After the first generation of GA takes place, the fittest-so-far (meatiest individual) is passed through the schemata. All zero-only spots (such as charLine[0][0], charLine[0][6] are dropped immediately. All asterisk "either-or" positions are evaluated. If charLine[0][1] is a '1', it is matched to all letters with a value of '1', and so on. The genome will then take the shape of the letter with the most matching values.... An important technical aspect of this that we have agreed on is to have the comparator only change the way the letters are displayed, while leaving their array intact--aside from the schemata. In other words, the original GA-defined chromosome/genome is maintained, while a copy of itself is stripped to be matched against the schemata. This allows it to maintain its evolutionary integrity with a level of abstraction so more fitness functions can be performed. I will deal more with this later. So how do we define the new fitness value, with both the schemata (likeness) and meatiness in mind? Here is a 5-step process that should do the job: 1. Take value of current generation individual. Let's use for genInd[5], say: 0000101011101110 2. Pass through schemata. Let's use generic letter line 5, which might be 00*****0******00, making genInd[5] now equal 0000101011101100 (the only bit that changes is the second-to-last one, because based on the schema that bit always equals 0). 3. Define "likeness value." For simplicity's sake let's use charAline[5] which equals 0000010001000000. For all bits of genInd[5] that match charAline[5], add a 1: So, comparing 0000101011101100 (genInd[5]) to 0000010001000000 (charAline[5]), and disregarding schemata characters that are always 0 (blue), we find only 4 bits that match (red), giving genInd[5] the "likeness" value of 4 as compared to charAline[5]. 4. Define the "meatiness value." To incorporate the "meatiness" factor, let's add an additional +1 to each value of matching letter that is, actually, "1" (meat). When we add up all the matching value of 1s between genInd[5] and charAline[5], we only get +1: 0000101011101100 compared to 0000010001000000. So, for this particular example, the meatiness value = 1. 5. Add "likeness value" and "meatiness value".To get the total fitness value, add the likeness value (4) to the meatiness value (1) for a total value of 5. Note: since this schemata line has 5 characters that are always equal to 0 (shown here: 00*****0******00), they are subtracted from the maximum fitness amount. So, the maximum fitness of this line is 16-5 = 11 possible values that match ("likeness" value), plus the possibility that all of those values are 1s ("meatiness" value), making the total maximum fitness of this line equal to: 11 (max "likeness") + 11 (max "meatiness") = 22. So in our example, 4 (likeness) + 1 (meatiness) = 5 was not all that great (5/22 = 23%). Other letters in the alphabet will much likely have higher fitness on this line. I think this will be a good way to determine total fitness--at least in early versions of Alphabet Soup. Future awesomeness: All technicalities aside, this is where Alphabet Soup can get really interesting. This will probably be around... version 3.0 or so. Right now, these are just vague ideas. Fitness based on letter shape was the original goal of Alphabet Soup all along:

"Hark! Here comes a second generation character, ‘i’, who has lost the vestigial tittle (the dot). Most other letters are unchanged or changed in a negative or neutral way. The lower mass of the ‘i’ makes it faster and take in less calories. Alas, it’s lower weight makes it do less damage and is losing ground to the dastardly ‘T’s and their hearty top most shield. Will the character genes be favorable enough to carry on or will they be lost and another random variation will make itself dominant. At the front of ‘i’s’ and ‘T’s’ war, a fork occurs with the ‘w’s. The ‘w’s strike fast coming down but their double point distributes the impacts, lessoning the effect on harder shelled letters like the ‘T'."

With this, things like food, environment and the ability to reproduce/fight/defend are all important. Another idea is this: fitness is dynamic, determined by the players. They change the landscape--by adding obstacles, giving new goals (such as winning a race, building a tower, et cetera). Different letters will be more suited to different tasks, so fitness will vary from task to task. This might keep it more interesting than if fitness was just based on one thing (like meatiness or shape). Also, on the note of shape mattering--maybe shape won't matter as much as far as fitness value is concerned, however shape may be important for movement in Farseer if we can get the physics of it right. So... if the goal is to get over a mountain or something, the shape and physics will be important to the letter's success, indirectly having an effect on the fitness anyway. A good comparison is to think of how to keep a Sim alive: by balancing a variety of values that are important to the character's success at staying alive, such as social value, food, health, activity, recreation, knowledge, and so on. Any of these kinds of ideas could be incorporated into the fitness value to make it more interesting and keep the player more involved in what is happening in the Soup. One important key to this is to allow the Evolutionary Computation to do its thing without interferring. If we can hone that delicate balance between the EC and the player-letter interaction, Alphabet Soup could be great. The future awesomeness of Alphabet Soup depends on our ability to come up with more fitness ideas, and to make them actually work. Other considerations: We have talked a lot about including sensing organs for letters to be able to interact with their environment on a biological level. Also in discussion are color values which may or may not be related to fitness, sensing ability, or overall health of a letter. We will have to deal more with these ideas and see what we can agree on. One thing we have reached consensus on is the level of abstraction that will be present in our final product. Overall, we are going to let the GA and GP do their things in a very precise way, keeping the Evolutionary Computation aspect as pure as possible--but this will all be going on behind the scenes. The precision in the background will be modified and "rounded" (such as with the schemata) before reaching the eyes of the player. This will allow the letters to maintain their forms, allow the Physics Engine to operate on fixed shapes, and so on. However there will likely be a more abstract level of EC going on as well, such as with the shapes present in the physics engine and how they react to one another. The more levels of EC operating within the game, the more rich the environment and the more capable it will be of surprising us. But we don't want the abstraction to completely cover up what is going on behind the scenes. One way to be able to unite the abstraction with the player's awareness of what is going on is through keeping a detailed history of each genome in the population. We should somehow tie the chromosomes to their respective genome so that the genome holds its identity and evolutionary lifespan throughout its own history. Maybe stamp each chromosome with some sort of hidden i.d. assigning it to its current genome. These generational histories will provide the owner of the letter with information showing how old the letter is (how many generations it has survived) and each detailed transformation it has undergone during its evolution to its current state. This could be useful for farming, trading or even--who knows--combat? Dog-fighting is illegal, but how about pitting our letters against each other? There are all kinds of scenarios and places we could go with Alphabet Soup. And as the creators of Dwarf Fortress believe, the more ideas we integrate, the better the game might become.

Our Generation’s Frontier

The Villain — Tue, 30 Mar 2010 08:53:37 +0000

(originally published August 15, 2009 here) The convergence of technology and biology could be the hallmark of our time. As the two systems become more closely intertwined, inevitable questions arise about life, AI and the force of evolution behind it all. It is worth noting that life itself is not the force; life is the manifestation of consciousness and self-awareness operating on top of a set of preordained principles. These are the same principles behind evolution and computation, all based on the laws of mathematics and probability. So it should not surprise us that when given a choice, computer programs will act eerily similar to their biological counterparts. This includes adaptation and natural selection. These base instincts are built into both systems, because these are defined at the most basic level: mathematics. This should be obvious when we consider technology in the digital era rests entirely on ones and zeros. So life is not the same as the evolutionary processes we are getting out of computer programs, but that misses the point. These evolutionary processes, input into today’s powerful computers, are capable of producing results which our biological life simply cannot. We humans operate by the same rules as the software we create, but toward different ends. Our survival depends on our physical, biological bodies, while computer data exists in hard drives and on an apparently immortal, intangible web. Our capabilities are limited by the concerns of our physical survival, while computers are limited only by the commands we give them, their processing power, and memory capacity. And as time moves on, each of these categories becomes less and less of a limitation. Our physical bodies inhibit us, for now and the foreseeable future, but the limits of computers are being stripped quickly. At their core, biological life and technology are basically systems operating on a larger playing field. For any system within the realm of all possible things, there is an inherent scope, or set of limitations. These limitations may be defined by physics (gravity, Thermodynamics), biology (germs, cells, DNA), computer technology (protocols such as TCP/IP, programming languages such as C), and so on. In other words, each of these systems, while operating on the same basic principles, must function within established, historically-defined boundaries. Within these boundaries, there is always a process occurring. Living and “apparently alive” systems never remain static; they are always evolving in a direction, toward a goal or goals. Our direction points toward the goal of survival and reproduction. The direction of technology tends to follow that same trajectory, because we use it toward our own end. More specifically, computer software works towards whatever goals we define for it. It is important, then, that we define useful goals. I think we are barely scratching the surface of what software is capable of producing for our purposes. We need to focus more on asking the right questions, pointing the software in the right direction, and letting it evolve to meet our needs.
It is interesting to find that there are certain laws that pervade these different systems in similar ways. I am not referring to the boundaries within the realm of possibilities, but instead trends that seem to arise out of the various systems and processes. One trend, “The Law of Accelerating Returns” (for example, Moore’s Law) tends to follow an S-Curve of exponential growth which is always replaced by another S-curve involving a phase shift to a completely new idea driving toward the same goal—only after the previous idea has reached its full potential. It is as if, within the realm of all possible things, these trends exist to explore and weed out—ruthlessly—the best possible outcomes for the given system. And this “law” is almost uncanny it its ability to do so. Moore’s Law is, essentially, Natural Selection… in technology. What drives this apparent force which crosses over technological and biological boundaries? For an answer there is no consensus, except that there seems to be more to it than simply the economy or self-fulfilling prophecy. We call them laws, simply because they seem to exist well-beyond and in spite of our individual efforts, and in a mathematically precise way that we as humans could not control even if we tried. It is almost as if trends such as this are hive mind-induced. After all, they seem to (directly or indirectly) aid in our primary goal as a whole society: in general the survival and thriving of humanity. In his blog The Technium, Kevin Kelly gets more specific and lists six things for which he believes living systems strive: “increasing complexity, sentience, consilience, specialization, possibilities and choices.” Upon closer examination, such trends as The Law of Accelerating Returns, Natural Selection, and Adaptation usually move us toward some or most of these goals. Then there is the parallel to consider of human minds to computer software. The primary difference between the two is that software lacks self-awareness and self-importance which are what make us as humans conscious (or is it consciousness that makes us self-aware?). For machines, this self-understanding has to be artificially induced by us. Beyond that, the available data sets, processing power and memory of the machines are vastly superior to our limited biological minds. The bottom line is, we can use computers to get answers we are incapable of deriving ourselves, and as computing limitations become less and less of a factor, we will be wise to take advantage of this vast, unprecedented potential.