/// <reference path="Statistics.ts" />

interface Named {

name: string;

}

interface Individual extends Named {

getGenotype(): Genotype;

getFitness(): number;

}

interface Tile extends Named {

isHazard: boolean;

fight(a: Agent);

flight(a: Agent);

harvest(a: Agent);

improve(a: Agent);

getImproveCost(): number;

}

class RuntimeFactory {

static create<T>(className: string, instanceParameters) : T{

var newInstance = Object.create(window[className].prototype);

newInstance.constructor.apply(newInstance, instanceParameters);

return newInstance;

}

}

class BaseTile implements Tile {

public name: string = "BaseTile";

public isHazard: boolean;

public harvest(a: Agent) { }

public improve(a: Agent) { }

public fight(a: Agent) { }

public flight(a: Agent) { }

public getActionDescription(action: string) {

switch (action){

case "harvest":

return " harvests the ";

case "improve":

return " improves the ";

case "fight":

return " fights the ";

case "flight":

return " runs away from the ";

}

}

public getImproveCost(): number {

return 0;

}

}

class ResourceChance {

constructor(public resource: BaseTile, public chance: number) {}

}

class World {

private map: BaseTile[] = [];

private currentBiome: Biome;

private players: Agent[] = [];

private threadID: number;

private currentGeneration: number = 1;

private populationLifetime: number;

private run: number = 1;

private mutationRisk = .1;

constructor(public log: Log, public runtime:number, private initialPopulation:number, private generationLifetime: number) {

log.out("Simulation Start", "h2");

for(var i = 0; i < initialPopulation; i++){

this.players.push(new Agent());

}

this.generateMap();

this.populationLifetime = generationLifetime;

this.threadID = setInterval(this.tick.bind(this), 500);

}

closestResource(): BaseTile{

this.log.selectMapTile((this.generationLifetime - this.populationLifetime ) % (this.map.length / 2));

return this.map[this.generationLifetime - this.populationLifetime];

}

generateMap(){

this.map = [];

this.currentBiome = Biome.Grassland;

for (var i = 0; i < this.generationLifetime / 2; i++){

this.map.push(this.currentBiome.getResource());

}

this.renderMap();

this.map = this.map.concat(this.map);

}

renderMap() {

while (log.mapDiv.firstChild) {

log.mapDiv.removeChild(log.mapDiv.firstChild);

}

log.mapOut("Map", "h2");

for (var i = 0; i < this.map.length; i++) {

var resource = this.map[i];

log.mapOut(resource.name, "div", "tile resource-"+resource.name.toLowerCase());

}

}

generateGeneration(){

this.log.out("Repopulating", "h3");

var mindex: number = -1;

var min: number = 999;

for(var i = 0; i < this.players.length; i++){

if (this.players[i].getFitness() < min){

mindex = i;

min = this.players[i].getFitness();

}

this.log.out(this.players[i].geneString());

}

for(var i = this.players.length - 1; i > 0; i--){

if (this.players[i].getFitness() <= min)

this.players.splice(i, 1);

}

var survivingCount = this.players.length;

var newPlayers = [];

for(var i = 0; i < this.initialPopulation; i++){

var mom: Individual = this.players[Math.round(Math.random()*(survivingCount-1))];

var dad: Individual = this.players[Math.round(Math.random()*(survivingCount-1))];

newPlayers.push(new Agent(dad, mom));

}

this.players = newPlayers;

}

evaluateGeneration() {

this.players.forEach(p => {

Statistics.Tracker.logAgent(p.name, p.geneString(), p.getFitness());

});

this.log.out("Best Agent: " + Statistics.Tracker.bestAgentName + ": ¢" + Statistics.Tracker.bestAgentFitness, "h3");

this.log.out("Best Genes: " + Statistics.Tracker.bestAgentGeneString, "h3");

}

tick(){

this.log.out("Turn #"+(this.run), "h4");

var statuses = [];

this.log.out("Current tile: " + this.closestResource().name, "p")

//idea: sort player time by 'speed' rating

this.players.forEach(p => {

statuses.push(p.tick(this, this.log));

});

statuses.forEach(s =>{

this.log.out(s, "span");

});

this.log.out("|", "span");

this.run++;

if (this.run > this.runtime) {

this.evaluateGeneration();

clearInterval(this.threadID);

this.log.out("Simulation Finished", "h2");

return;

}

this.populationLifetime--;

if (this.populationLifetime === 0) {

this.evaluateGeneration();

this.generateGeneration();

this.generateMap();

this.currentGeneration++;

this.populationLifetime = this.generationLifetime;

this.log.out("Beginning generation "+this.currentGeneration, "h3")

}

}

}

// exposes properties for expression (name, value) and inheritance (dominant, recessive)

class Gene implements Named{

static geneNames: string[] = ["shy", "aggression", "intelligence", "curiosity"];

public dominant: boolean = true;

public degree: number;

public multiple: boolean = false;

get isDominant(): boolean{

return this.dominant;

}

get isRecessive(): boolean{

return !this.dominant;

}

constructor(public name: string,

rawValue: string,

public dominantExpression:any,

public recessiveExpression: any){

this.dominant = rawValue[0] === rawValue[0].toUpperCase();

}

static create(name: string, chromatin: string): Gene{

return RuntimeFactory.create<Gene>(name, [name, chromatin]);

}

}

class ShyGene extends Gene{

constructor(public name: string,

rawValue: string){

super(name, rawValue, false, true);

}

}

class AggressionGene extends Gene{

constructor(public name: string,

rawValue: string){

super(name, rawValue, true, false);

}

}

class CuriosityGene extends Gene{

constructor(public name: string,

rawValue: string){

super(name, rawValue, false, true);

}

}

class IntelligenceGene extends Gene{

constructor(public name: string,

rawValue: string) {

super(name, rawValue, false, true);

}

}

// idea: a 'curiousity' gene that controls whether or not an individual interacts with the mutator resource

// idea: speed rating = sprint + (endurance*food)

// idea: 'sprint' and 'endurance' phenotypes

// idea: Memes - socially acquired traits

// a chromosome is a collection of loci (a string:Gene map)

class Chromosome{

public geneMap: Object = {};

constructor(rawChromatin? : string){

var values;

if (rawChromatin){

values = rawChromatin.split("|");

} else {

values = null;

}

for(var i = 0; i < Gene.geneNames.length; i++){

// todo: move this to gene.create

// todo: actually reference inherited chromatin from the rawChromatin/values collection

var typeName: string = Gene.geneNames[i].substr(0, 1).toUpperCase() + Gene.geneNames[i].substring(1) + "Gene";

var rawValue: string;

if (values == null) {

// by default, 50% chance to have either dominant or recessive gene

rawValue = (Math.random() > .5) ? "D" : "d";

} else {

rawValue = values[i];

}

this.geneMap[Gene.geneNames[i]] = Gene.create(typeName, rawValue);

}

}

mutate(){

}

getChromatin(geneName: string): string{

var output: string = "";

// output += this.geneMap[geneName].value + ":";

output += (this.geneMap[geneName].isDominant ? "D" : "d");

return output;

}

}

// a genotype holds two chromosomes and exposes the GeneExpression API for phenotypes

class Genotype{

private chromosomeA: Chromosome;

private chromosomeB: Chromosome;

private phenotype: Object = {};

constructor(environmentalMutationRisk: number, parentA?: Individual, parentB?: Individual){

var chrA: string;

var chrB: string;

// upon creation, either inherit randomly from parental genotypes

if (parentA && parentB){

var gA: Genotype = parentA.getGenotype();

var gB: Genotype = parentB.getGenotype();

// extract the chromatin

chrA = gA.getChromatin();

chrB = gB.getChromatin();

}

// or randomly create a new genotype

// finalize with some transposition

if (Math.random() < environmentalMutationRisk){

// transpose

}

this.chromosomeA = new Chromosome(chrA);

this.chromosomeB = new Chromosome(chrB);

// and possibly randomly mutate a gene or two

if (Math.random() < environmentalMutationRisk){

if (Math.random() > .5) {

this.chromosomeA.mutate();

} else {

this.chromosomeB.mutate();

}

}

}

expressedPhenotype(geneName: string){

var cachedPhenotype: any = this.phenotype[geneName];

if (cachedPhenotype != null) {

return cachedPhenotype;

} else {

var gA: Gene = this.chromosomeA.geneMap[geneName];

// if it's dominant, it's expressed

if (gA.isDominant){

this.phenotype[geneName] = gA.dominantExpression;

} else {

var gB: Gene = this.chromosomeB.geneMap[geneName];

if (gB.isDominant){

this.phenotype[geneName] = gB.dominantExpression;

} else {

this.phenotype[geneName] = gB.recessiveExpression;

}

}

return this.phenotype[geneName];

}

}

getChromatin(): string{

var str = "";

for(var i = 0; i < Gene.geneNames.length; i++){

if (Math.random() > .5) {

str += this.chromosomeA.getChromatin(Gene.geneNames[i]);

} else {

str += this.chromosomeB.getChromatin(Gene.geneNames[i]);

}

if (i < Gene.geneNames.length - 1) {

str += "|";

}

}

return str;

}

status(): string{

var output: string = "";

for(var i = 0; i < Gene.geneNames.length; i++){

var thisName = Gene.geneNames[i];

var left: Gene = this.chromosomeA.geneMap[thisName];

var right: Gene = this.chromosomeB.geneMap[thisName];

thisName = thisName.substr(0, 3);

if (left.isRecessive && right.isRecessive) {

output += thisName;

} else if (left.isDominant && left.isDominant) {

output += thisName.toUpperCase();

} else {

output += thisName[0].toUpperCase() + thisName.substr(1, 2);

}

if (i < Gene.geneNames.length - 1) {

output += "|";

}

}

return output;

}

}

class AgentMemoryBank {

private store: Object = {};

addMemory(situation: string, action: string, utilityChange: number) {

if ((this.store[situation] == null) || (this.store[situation].utilityChange < utilityChange))

this.store[situation] = new AgentMemory(utilityChange, action);

}

remember(situation: string) {

if (this.store[situation] == null || this.store[situation].utilityChange > 0)

return '';

else

return this.store[situation].action;

}

}

class AgentMemory {

constructor(public utilityChange: number, public action: string) { }

}

class Agent implements Named, Individual{

food: number = 0;

private genotype: Genotype;

public name: string;

private memory: AgentMemoryBank = new AgentMemoryBank();

get displayName(): string{

return "<span style='color:darkblue;font-weight:bold'>"+this.name+"</span>";

}

static names: string[] = ["Lex", "Ram", "Car", "Dig", "Red", "Bin", "Ana", "Lib", "Sis", "Net", "Led", "Bus"];

static getRandomName(): string {

return Agent.names[Math.round(Math.random()*(Agent.names.length-1))];

}

static getLastName(name: string): string{

var split: string[] = name.split(" ");

if (split.length > 1) {

return split[1];

} else {

return name;

}

}

static getFamilyName(m: Individual, d: Individual){

var mStr = Agent.getLastName(m.name);

var dStr = Agent.getLastName(d.name);

if (mStr.length > 3) {

return dStr;

}

return dStr + mStr.toLowerCase();

}

constructor(private dad?: Individual, private mom?: Individual) {

if (dad && mom){

this.name = Agent.getRandomName() + " " + Agent.getFamilyName(mom, dad);

this.genotype = new Genotype(.5, dad, mom);

} else {

this.name = Agent.getRandomName();

this.genotype = new Genotype(.5);

}

}

getGenotype() {

this.memory['green'] = 'blue';

return this.genotype;

}

getFitness():number{

return this.food;

}

status(): string{

return ("| " + this.name + ": " + this.food + "¢ ");

}

geneString(): string{

return ("| "+this.genotype.status()+" |");

}

//idea: memory - given inputs, remember most utility move

//idea: pass down the tick to the individual phenotype

//then you can completely abstract this

//you'd then have a ordering problem though, aka which phenotype kicks in first?

tick(world: World, log: Log): string{

if (this.genotype.expressedPhenotype("shy") && (Math.random() > .5)){

log.out(this.displayName +" does nothing");

} else {

var r = world.closestResource(),

oldUtility = this.food,

isFarm = r instanceof Farm,

isPredator = r instanceof BasePredator,

isCache = r instanceof Granary,

action = "",

situation = isFarm+"|"+isPredator+"|"+isCache;

action = this.memory.remember(situation);

if (action == "") {

if (isPredator) {

if (this.genotype.expressedPhenotype("aggression") && this.food > r.getImproveCost()) {

action = "fight";

} else {

action = "flight";

}

} else if (isFarm) {

if (this.genotype.expressedPhenotype("intelligence") && this.food > r.getImproveCost()) {

action = "improve";

} else {

action = "harvest";

}

} else if (isCache) {

var harvestNotStore = Math.random() > .5;

if (this.genotype.expressedPhenotype("intelligence") || harvestNotStore) {

action = "harvest";

} else {

action = "improve";

}

}

} else {

console.log(this.name + " remembers to "+ action);

}

//actually do the thing

r[action](this);

log.out(this.displayName + r.getActionDescription(action) + r.name + "<span class='badge'>" + (this.food - oldUtility) + "</span>");

//add a memory with the situation, action used, and change in utility

this.memory.addMemory(situation, action, this.food - oldUtility);

}

return this.status();

}

}

//todo - change hierarchy to tile > resource + hazard

class Farm extends BaseTile{

public isHazard: boolean = false;

private cropYield: number = 1;

public name: string = "Farm"; //todo: farms are staying improved across generations???

harvest(a: Agent) {

a.food += this.cropYield;

}

getImproveCost(): number{

return this.cropYield + 1;

}

improve(a: Agent){

a.food -= this.getImproveCost();

this.cropYield++;

}

}

class Granary extends BaseTile{

public isHazard: boolean = false;

private cache: number = 1;

public name: string = "Granary";

harvest(a: Agent) {

a.food += this.cache;

this.cache = 3;

}

getImproveCost(): number{

return 999;

}

improve(a: Agent){

this.cache++;

}

}

class BasePredator extends BaseTile{

public isHazard: boolean = true;

protected health: number = Math.round(Math.random()*2)+1;

public name: string = "BasePredator";

fight(a: Agent) {

a.food--;

this.health--;

}

//todo: have this modified by an alertness or athletic rating

flight(a: Agent) {

if (this.health > 0 && Math.random() > .5) {

a.food--;

}

}

harvest(a: Agent) {}

getImproveCost(): number{

return this.health;

}

improve(a: Agent){

}

}

class Predator extends BasePredator {

constructor() {

super();

this.name = "Predator";

}

flight(a: Agent) {

if (this.health > 0 && Math.random() > .5) {

a.food--;

}

}

fight(a: Agent) {

a.food--;

this.health--;

}

}

// idea: a resource that increases the mutation risk of an individual

class Biome {

private Chances: ResourceChance[] = [];

constructor(mappings: Object) {

//todo: sort by chance first

//fixme: it's only creating one instance per biome, which is wrong

//runtimefactory.create needs to be moved to getResource

for (var key in mappings) {

this.Chances.push(new ResourceChance(RuntimeFactory.create<BaseTile>(<string> key, null), <number> mappings[key]));

}

}

getResource(): BaseTile {

var rand = Math.floor(Math.random() * 100);

//console.log('Getting ' + rand + 'th percentile resource');

var chanceSum = 0;

for (var i = 0; i < this.Chances.length; i++) {

chanceSum += this.Chances[i].chance;

//console.log(this.Chances[i].resource.name+' is in the ' + chanceSum + 'th percentile');

if (rand <= chanceSum) {

return this.Chances[i].resource;

}

}

return this.Chances[this.Chances.length - 1].resource;

}

static Grassland: Biome = new Biome({

'Predator': 20,

'Granary': 40,

'Farm': 40

});

}

class Log {

public logDiv: HTMLDivElement;

public mapDiv: HTMLDivElement;

constructor(private centerDiv: Node) {

this.logDiv = <HTMLDivElement>this.centerDiv.childNodes[1];

this.mapDiv = <HTMLDivElement>this.centerDiv.childNodes[3];

}

mapOut(content: string, element?: string, classString?: string) {

this.write(content, element || "div", classString || "", true);

}

out(content: string, element?: string, classString?: string){

this.write(content, element || "div", classString || "", false);

}

private write(content: string, element: string, classString: string, toMap: boolean) {

var newDiv = document.createElement(element);

newDiv.innerHTML = content;

newDiv.className = classString;

if (toMap) {

this.mapDiv.appendChild(newDiv);

} else {

this.logDiv.appendChild(newDiv);

}

}

selectMapTile(index: number) {

var oldSelecteds: NodeList = this.mapDiv.querySelectorAll(".current");

if (oldSelecteds.length > 0) {

var oldSelected: HTMLDivElement = <HTMLDivElement>oldSelecteds[0];

oldSelected.classList.remove("current");

}

var newSelected: HTMLDivElement = <HTMLDivElement>this.mapDiv.querySelectorAll(".tile")[index];

newSelected.classList.add("current");

}

}

var log: Log = new Log(document.getElementsByClassName("center")[0]);

var world: World = new World(log, 48, 5, 8);