app/World/Classes/AI/AIGrudge.ts

@@ -1,5 +1,4 @@
 /// <reference path="../AI.ts" />
-///<reference path="../ContentPicker/ContentMarker.ts"/>
 module AIRules {
 
 }

app/World/Classes/AI/Reaction/ReactToAggressive.ts

@@ -1,28 +1,8 @@
 /// <reference path="../../AI.ts" />
-///<reference path="../../ContentPicker/ContentMarker.ts"/>
 module AIRules {
-// Only one at a time
-    export var actionMin = new ContentMarker("That pissed me off a little", true);
-    export var actionMed = new ContentMarker("That pissed me off", true);
-    export var actionMax = new ContentMarker("That pissed me off HARD", true);
 
-    // Only one at a time
-    export var resultNotHostile = new ContentMarker("I'm not gonna do anything about it", true);
-    export var resultRetaliate = new ContentMarker("I'll hit you once so you can see how you like it", true);
-    export var resultHostile = new ContentMarker("I'll hit you until you drop dead.", true);
-
-    export function printGrudgeResult (aggressor : Thing, victim : Person, ...markers : Array<ContentMarker>) : Say {
-        let group = new ContentGroup();
-        let unit = new CombatPokeUnit();
-        group.addUnit(unit);
-        unit.setTarget(victim);
-        unit.setAggressor(aggressor);
-        unit.addMarker(...markers);
-
-        if (aggressor == WorldState.player) {
-            victim.AI.warnedTimes++;
-        }
-        return new Say(...CombatPokeDescription.getDescription(group));
+    export function printGrudgeResult (atom : ContentAtomAnnoy) : Say {
+        return ContentMoleculeAnnoy.getSay(new ContentMolecule(atom));
     }
 
     export var actedUponAggressively = AI.reacttoRules.createAndAddRule({
@@ -45,30 +25,31 @@ module AIRules {
             let ai = person.AI;
             let response : Say;
             let gain = ai.grudgeRate * action.aggressivenessRating;
-            let actionLevel = actionMin;
-            let result = resultNotHostile;
+            let actionLevel = ContentAtomAnnoy.TYPE_LOW;
+            let result = ContentAtomAnnoy.RESULT_FRIENDLY;
             if (ai.getHostilityTo(action.actor) > 100) {
-                result = resultHostile;
+                result = ContentAtomAnnoy.RESULT_HOSTILE;
             } else if (ai.retaliates && ai.getHostilityTo(action.actor) >= (ai.hostileThreshold / 2)) {
-                result = resultRetaliate;
+                result = ContentAtomAnnoy.RESULT_PISSED;
             }
             if (gain >= (ai.hostileThreshold / 2)) {
-                actionLevel = actionMax;
+                actionLevel = ContentAtomAnnoy.TYPE_HIGH;
             } else if (gain >= (ai.hostileThreshold / 4)) {
-                actionLevel = actionMed;
+                actionLevel = ContentAtomAnnoy.TYPE_MEDIUM;
             }
-            response = printGrudgeResult(action.actor, person, actionLevel, result);
+            response = printGrudgeResult(new ContentAtomAnnoy(action.actor, person, [actionLevel, result]));
 
             let nAct : Action;
-            if (result == resultRetaliate) {
+            if (result != ContentAtomAnnoy.RESULT_FRIENDLY) {
                 nAct = new ActionAttack(person, action.actor);
                 nAct.finalSay = response.add(Say.PARAGRAPH_BREAK);
                 nAct.finalSayOnEnd = false;
+                person.AI.storedReaction = nAct;
             } else {
-                nAct = new ActionWait(person);
-                nAct.finalSay = response.add(Say.PARAGRAPH_BREAK);
+                // nAct = new ActionWait(person);
+                // nAct.finalSay = response.add(Say.PARAGRAPH_BREAK);
+                // Stop waiting when hit?
             }
-            person.AI.storedReaction = nAct;
         },
         conditions : (runner : RulebookRunner<Person>) => {
             let pai = runner.noun.AI;

app/World/Classes/Action/ActionAttack.ts

@@ -97,8 +97,8 @@ class ActionAttack extends Action {
         return "attack " + this.getNoun(0).getPrintedName() + " with " + weaponName;
     }
 
-    public generateDescription (group : ContentGroup) {
-        this.say.add(...(CombatDescription.getDescription(group)));
+    public generateDescription (group : ContentMolecule) {
+        this.say.add(ContentMoleculeCombat.getSay(group));
     }
 
     public static checkAttackable = ActionAttack.check.createAndAddRule({
@@ -222,14 +222,14 @@ class ActionAttack extends Action {
 
         if (!isHit) {
             action.generateDescription(
-                (new ContentGroup())
-                    .addUnit(
-                        (new CombatUnit())
-                            .setActor(actor)
-                            .setTarget(target)
-                            .setWeapon(...action.getWeapons())
-                            .addMarker(CombatHit.MISS)
+                new ContentMolecule(
+                    new ContentAtomCombat(
+                        actor,
+                        target,
+                        action.getWeapons(),
+                        [ContentAtomCombat.MISS]
                     )
+                )
             );
             return; // End of action
         }
@@ -264,32 +264,32 @@ class ActionAttack extends Action {
 
         let markers = [];
         if (finalDamage >= criticalHitThreshold) {
-            markers.push(CombatHit.CRITICAL);
+            markers.push(ContentAtomCombat.CRITICAL);
         } else {
-            markers.push(CombatHit.HIT);
+            markers.push(ContentAtomCombat.HIT);
         }
 
         if (previousHealth > 0 && finalHealth <= 0) {
-            markers.push(CombatResult.KNOCKED_OFF);
+            markers.push(ContentAtomCombat.KNOCKED_OFF);
             target.stance = PersonStance.KNOCKEDOUT;
         } else if (finalHealth <= -10) {
-            markers.push(CombatResult.KILLED);
+            markers.push(ContentAtomCombat.KILLED);
             target.stance = PersonStance.KNOCKEDOUT;
             target.die();
         } else if (isKnockedDown) {
-            markers.push(CombatResult.KNOCKED);
+            markers.push(ContentAtomCombat.KNOCKED);
             target.stance = PersonStance.ALLFOURS;
         }
 
         action.generateDescription(
-            (new ContentGroup())
-                .addUnit(
-                    (new CombatUnit())
-                        .setActor(actor)
-                        .setTarget(target)
-                        .setWeapon(...action.getWeapons())
-                        .addMarker(...markers)
+            new ContentMolecule(
+                new ContentAtomCombat(
+                    actor,
+                    target,
+                    action.getWeapons(),
+                    markers
                 )
+            )
         );
     }
 
@@ -302,26 +302,26 @@ class ActionAttack extends Action {
 
         if (actorDamage >= target.breakableOn) {
             action.generateDescription(
-                (new ContentGroup())
-                    .addUnit(
-                        (new CombatUnit())
-                            .setActor(actor)
-                            .setTarget(target)
-                            .setWeapon(...action.getWeapons())
-                            .addMarker(CombatHit.CRITICAL)
+                new ContentMolecule(
+                    new ContentAtomCombat(
+                        actor,
+                        target,
+                        action.getWeapons(),
+                        [ContentAtomCombat.CRITICAL]
                     )
+                )
             );
             target.break();
         } else {
             action.generateDescription(
-                (new ContentGroup())
-                    .addUnit(
-                        (new CombatUnit())
-                            .setActor(actor)
-                            .setTarget(target)
-                            .setWeapon(...action.getWeapons())
-                            .addMarker(CombatHit.HIT)
+                new ContentMolecule(
+                    new ContentAtomCombat(
+                        actor,
+                        target,
+                        action.getWeapons(),
+                        [ContentAtomCombat.HIT]
                     )
+                )
             );
         }
     }

app/World/Classes/ContentPicker/Annoy/ContentAtomAnnoy.ts

@@ -0,0 +1,52 @@
+///<reference path="../ContentAtom.ts"/>
+///<reference path="../ContentNounSimple.ts"/>
+/**
+ * This atom should be used in place of the default atom when handling Annoying people.
+ * Do note that any aggressive action is automatically Annoying.
+ */
+class ContentAtomAnnoy extends ContentAtom {
+    /**
+     * Only one of the following markers appears at once. Will always contain one of those.
+     */
+    public static TYPE_LOW = new ContentNounSimple("LOW ANNOYING LEVEL");
+    public static TYPE_MEDIUM = new ContentNounSimple("MEDIUM ANNOYING LEVEL");
+    public static TYPE_HIGH = new ContentNounSimple("HIGH ANNOYING LEVEL");
+
+    /**
+     * Only one of the following markers appears at once. Will always contain one of those.
+     */
+    public static RESULT_FRIENDLY = new ContentNounSimple("TARGET IS STILL FRIENDLY");
+    public static RESULT_PISSED = new ContentNounSimple("TARGET IS GETTING PISSED OFF");
+    public static RESULT_HOSTILE = new ContentNounSimple("TARGET IS NOW HOSTILE");
+
+
+    public annoyer : any;
+    public target : any;
+    public markers : ContentAtom = new ContentAtom();
+
+    constructor (attacker : any, target : any, markers : Array<ContentNounSimple> = []) {
+        super();
+        this.annoyer = attacker;
+        this.target = target;
+        this.markers.addNoun(...markers);
+    }
+
+    public compareAgainst (other : ContentAtom) {
+        if (other instanceof ContentAtomAnnoy) {
+            return (
+                ContentAtom.compareNoun(this.annoyer, other.annoyer) &&
+                ContentAtom.compareNoun(this.target, other.target) &&
+                this.markers.compareAgainst(other.markers)
+            );
+        }
+        return false;
+    }
+
+    public getAtomPriority () {
+        return (
+            ContentAtom.weightNoun(this.annoyer) +
+            ContentAtom.weightNoun(this.target) +
+            this.markers.getAtomPriority()
+        );
+    }
+}

app/World/Classes/ContentPicker/Annoy/ContentMoleculeAnnoy.ts

@@ -0,0 +1,67 @@
+///<reference path="../ContentMolecule.ts"/>
+class ContentMoleculeAnnoy extends ContentMolecule {
+    protected say : Say | ((attacker : any, target : any, markers : Array<ContentNounSimple>) => Say);
+    protected saidTimes = 0;
+
+    public constructor (description : Say | ((attacker : any, target : any, markers : Array<ContentNounSimple>) => Say)) {
+        super();
+        this.say = description;
+        ContentMoleculeAnnoy.MOLECULES.push(this);
+    }
+
+    public getSay(specificMolecule : ContentMolecule) {
+        this.saidTimes++;
+        if (this.say instanceof Say) {
+            return this.say;
+        } else {
+            let combatAtom = <ContentAtomAnnoy>(specificMolecule.getAtoms()[0]);
+            return this.say(combatAtom.annoyer, combatAtom.target, combatAtom.markers.getNouns());
+        }
+    }
+
+    public getWeight () {
+        // TODO: Check if this implementation is good enough.
+        let weight = -this.saidTimes;
+        this.atoms.forEach(value => {
+            weight += value.getAtomPriority()
+        });
+        return weight;
+    }
+
+    protected static MOLECULES = [];
+
+    /**
+     * Searches for Combat molecules that describe the specificMolecule given. Assumes Atoms are of the Combat variety. Assumes there is always a single Atom.
+     * @param specificMolecule
+     */
+    public static getSay (specificMolecule : ContentMolecule) {
+        // Randomize the array to prevent the same message from showing up every time
+        let many : Array<ContentMoleculeAnnoy> = new Shuffler(ContentMoleculeAnnoy.MOLECULES).getShuffled();
+
+        // Order the array placing higher priority messages on top, but messages with same priority are still randomized
+        many.sort((a, b) => {
+            return b.getWeight() - a.getWeight()
+        });
+
+        let matches = specificMolecule.findMatches(many);
+        if (matches.length == 0) {
+            let atom = <ContentAtomAnnoy> specificMolecule.getAtoms()[0];
+            Elements.CurrentTurnHandler.printAsError(
+                new Say(
+                    "Unable to find match for this annoying passage. Attacker: ", atom.annoyer,
+                    ". Target: ", atom.target,
+                    ". Markers: ", ...(atom.markers.getNouns()),
+                    ". Please report for fixing."
+                )
+            );
+            return new Say();
+        } else {
+            let finalSay = new Say();
+            matches.forEach((idx : number) => {
+                finalSay.add(ContentMoleculeAnnoy.MOLECULES[idx].getSay(specificMolecule));
+                finalSay.add(" ");
+            });
+            return finalSay;
+        }
+    }
+}

app/World/Classes/ContentPicker/Combat/ContentAtomCombat.ts

@@ -23,7 +23,7 @@ class ContentAtomCombat extends ContentAtom {
     public weapons : ContentAtom = new ContentAtom();
     public markers : ContentAtom = new ContentAtom();
 
-    constructor (attacker : any, target : any, weapons : Array<any> = [], markers : Array<ContentNounSimple> = []) {
+    constructor (attacker : any, target : any, weapons : Array<any> = [], markers : Array<ContentNounSimple | ContentNoun> = []) {
         super();
         this.attacker = attacker;
         this.target = target;
@@ -33,6 +33,13 @@ class ContentAtomCombat extends ContentAtom {
 
     public compareAgainst (other : ContentAtom) {
         if (other instanceof ContentAtomCombat) {
+            console.warn(
+                ContentAtom.compareNoun(this.attacker, other.attacker) &&
+                ContentAtom.compareNoun(this.target, other.target) &&
+                this.weapons.compareAgainst(other.weapons) &&
+                this.markers.compareAgainst(other.markers),
+
+            );
             return (
                 ContentAtom.compareNoun(this.attacker, other.attacker) &&
                 ContentAtom.compareNoun(this.target, other.target) &&

app/World/Classes/ContentPicker/Combat/ContentMoleculeCombat.ts

@@ -7,6 +7,7 @@ class ContentMoleculeCombat extends ContentMolecule {
         super();
         this.say = description;
         ContentMoleculeCombat.MOLECULES.push(this);
+        console.warn(this);
     }
 
     public getSay(specificMolecule : ContentMolecule) {
@@ -28,10 +29,10 @@ class ContentMoleculeCombat extends ContentMolecule {
         return weight;
     }
 
-    protected static MOLECULES = [];
+    protected static MOLECULES : Array<ContentMoleculeCombat> = [];
 
     /**
-     * Returns an array of ContentMoleculeCombat that fulfill ContentMolecule given.
+     * Searches for Combat molecules that describe the specificMolecule given. Assumes Atoms are of the Combat variety. Assumes there is always a single Atom.
      * @param specificMolecule
      */
     public static getSay (specificMolecule : ContentMolecule) {
@@ -55,27 +56,14 @@ class ContentMoleculeCombat extends ContentMolecule {
                     ". Please report for fixing."
                 )
             );
+            return new Say();
         } else {
             let finalSay = new Say();
-            matches.forEach((value : ContentMoleculeCombat) => {
-                finalSay.add(value.getSay(specificMolecule));
+            matches.forEach((idx : number) => {
+                finalSay.add(ContentMoleculeCombat.MOLECULES[idx].getSay(specificMolecule));
                 finalSay.add(" ");
             });
             return finalSay;
         }
     }
-}
-
-// new ContentMoleculeCombat(
-//     (attacker, target, weapons, markers) => {
-//         return new Say("Woohoo");
-//     }
-// ).addAtom(
-//     new ContentAtomCombat(
-//         Person,
-//         Person,
-//         [Thing],
-//         [new ContentNoun(ContentAtomCombat.HIT, ContentAtomCombat.CRITICAL).setType(ContentNounType.FULLY_ADAPTIVE), ContentAtomCombat.KNOCKED_OFF]
-//     )
-// );
-// Definitely tons saner than the current implementation
+}

app/World/Classes/ContentPicker/ContentMolecule.ts

@@ -17,9 +17,10 @@ class ContentMolecule {
         return this.atoms;
     }
 
-    public findMatches (many : Array<ContentMolecule>) {
+    public findMatches (many : Array<ContentMolecule>, giveRelevant = false) {
         let missingAtoms = [...this.atoms];
         let chosenOnes = [];
+        let relevantAtoms : Array<ContentAtom> = [];
 
         for (let k = 0; k < many.length; k++) {
             let vagueMolecule = many[k]
@@ -33,7 +34,7 @@ class ContentMolecule {
                     let specificAtom = cachedAtoms[k];
                     if (specificAtom.compareAgainst(vagueAtom)) {
                         cachedAtoms.splice(k, 1);
-                        vagueAtoms.splice(i, 1);
+                        relevantAtoms.push(...vagueAtoms.splice(i, 1));
                         break;
                     }
                 }
@@ -49,6 +50,10 @@ class ContentMolecule {
             }
         }
 
+        if (giveRelevant) {
+            return relevantAtoms;
+        }
+
         if (missingAtoms.length == 0) {
             return chosenOnes; // Return best match
         } else {

app/World/Classes/ContentPicker/Fucking/ContentAtomFucking.ts

@@ -0,0 +1,95 @@
+///<reference path="../ContentAtom.ts"/>
+///<reference path="../ContentNounSimple.ts"/>
+/**
+ * This atom should be used in place of the default atom when handling Fucking.
+ */
+class ContentAtomFucking extends ContentAtom {
+    /**
+     * Only one of the following markers appears at once. They mean the style of what is going on.
+     */
+    public static GENTLE = new ContentNounSimple("GENTLE");
+    public static ROUGH = new ContentNounSimple("ROUGH");
+
+    /**
+     * These signify a state. If Pentrating and Removing appear together he probably insta-cummed and is already retreating in shame.
+     */
+    public static PENETRATING = new ContentNounSimple("PENETRATING");
+    public static REMOVING = new ContentNounSimple("REMOVING");
+
+    /**
+     * These signify a state. They'll usually appear all at once, but on rare cases some NPCs will have prolonged CUM_START before CUMMING, or last multiple turns on CUMMING, etc.
+     */
+    public static CUM_START = new ContentNounSimple("CUM_START");
+    public static CUMMING = new ContentNounSimple("CUMMING");
+    public static CUM_END = new ContentNounSimple("CUM_END");
+
+    /**
+     * These signify the style if any of the above CUMMING is happening. Probably never going to show both at once, since atoms deal with a single stick/hole combo, but I guess it's technically possible for some rare enemies?
+     */
+    public static CUM_INSIDE = new ContentNounSimple("CUM_INSIDE");
+    public static CUM_OUTSIDE = new ContentNounSimple("CUM_OUTSIDE");
+
+    /**
+     * These signify the current stance of the Fucked. In general you can assume that if standing, Vagina/Mouth = Fucker is in front, otherwise is behind, etc. We don't handle the fucker position separatedly. Maybe we should? No idea.
+     */
+    public static STANDING = new ContentNounSimple("STANDING");
+    public static ALLFOURS = new ContentNounSimple("ALLFOURS");
+
+    public fucked : any;
+    public fucker : any;
+    public hole : any;
+    public stick : any;
+    public markers : ContentAtom = new ContentAtom();
+
+    constructor () {
+        super();
+    }
+
+    public setFucked (fucked : any) {
+        this.fucked = fucked;
+        return this;
+    }
+
+    public setFucker (fucker : any) {
+        this.fucker = fucker;
+        return this;
+    }
+
+    public setHole (hole : any) {
+        this.hole = hole;
+        return this;
+    }
+
+    public setStick (stick : any) {
+        this.stick = stick;
+        return this;
+    }
+
+    public addMarker (...markers : Array<any>) {
+        this.markers.addNoun(...markers);
+        return this;
+    }
+
+    public compareAgainst (other : ContentAtom) {
+        if (other instanceof ContentAtomFucking) {
+            return (
+                ContentAtom.compareNoun(this.fucked, other.fucked) &&
+                ContentAtom.compareNoun(this.fucker, other.fucker) &&
+                ContentAtom.compareNoun(this.hole, other.hole) &&
+                ContentAtom.compareNoun(this.stick, other.stick) &&
+                this.markers.compareAgainst(other.markers)
+            );
+        }
+        return false;
+    }
+
+    public getAtomPriority () {
+        return (
+            ContentAtom.weightNoun(this.fucked) +
+            ContentAtom.weightNoun(this.fucker) +
+            ContentAtom.weightNoun(this.hole) +
+            ContentAtom.weightNoun(this.stick) +
+            this.markers.getAtomPriority()
+        );
+    }
+}

app/World/Classes/ContentPicker/Fucking/ContentMoleculeFucking.ts

@@ -0,0 +1,75 @@
+///<reference path="../ContentMolecule.ts"/>
+class ContentMoleculeFucking extends ContentMolecule {
+    protected say : Say | ((relevantAtoms : Array<ContentAtomFucking>) => Say);
+    protected saidTimes = 0;
+
+    public constructor (description : Say | ((relevantAtoms : Array<ContentAtomFucking>) => Say)) {
+        super();
+        this.say = description;
+        ContentMoleculeFucking.MOLECULES.push(this);
+    }
+
+    public getSay(specificMolecule : ContentMolecule, relevantAtoms : Array<ContentAtomFucking>) {
+        this.saidTimes++;
+        if (this.say instanceof Say) {
+            return this.say;
+        } else {
+            //let relevantAtoms = specificMolecule.findMatches([this.fuckingAtom])
+            //let fuckingAtom = <ContentAtomFucking>(specificMolecule.getAtoms()[0]);
+            return this.say(relevantAtoms);
+        }
+    }
+
+    public getWeight () {
+        // TODO: Check if this implementation is good enough.
+        let weight = -this.saidTimes;
+        this.atoms.forEach(value => {
+            weight += value.getAtomPriority()
+        });
+        return weight;
+    }
+
+    protected static MOLECULES : Array<ContentMoleculeFucking>  = [];
+
+    /**
+     * Searches for Fucking molecules that describe the specificMolecule given. Assumes atoms are of the Fucking variety.
+     * @param specificMolecule
+     */
+    public static getSay (specificMolecule : ContentMolecule) {
+        // Randomize the array to prevent the same message from showing up every time
+        let many : Array<ContentMoleculeFucking> = new Shuffler(ContentMoleculeFucking.MOLECULES).getShuffled();
+
+        // Order the array placing higher priority messages on top, but messages with same priority are still randomized
+        many.sort((a, b) => {
+            return b.getWeight() - a.getWeight()
+        });
+
+        let matches = specificMolecule.findMatches(many);
+        if (matches.length == 0) {
+            let say = new Say("Unable to find match for this sexual passage.");
+            specificMolecule.getAtoms().forEach((atom : ContentAtomFucking) => {
+                say.add(Say.LINE_BREAK, "Fucker: ", atom.fucker,
+                    ". Fucked: ", atom.fucked,
+                    ". Stick: ", atom.stick,
+                    ". Hole: ", atom.hole,
+                    ". Markers: ", ...(atom.markers.getNouns()),
+                    ". Please report for fixing."
+                );
+            });
+            Elements.CurrentTurnHandler.printAsError(say);
+            return new Say();
+        } else {
+            let finalSay = new Say();
+            matches.forEach((idx : number) => {
+                let value = ContentMoleculeFucking.MOLECULES[idx];
+                finalSay.add(
+                    value.getSay(
+                        specificMolecule, specificMolecule.findMatches([value], true)
+                    )
+                );
+                finalSay.add(" ");
+            });
+            return finalSay;
+        }
+    }
+}

app/World/Classes/ContentPickerOld/AdaptiveDifferential.ts

@@ -1,64 +0,0 @@
-///<reference path="ContentDifferential.ts"/>
-class AdaptiveDifferential {
-    public compareFunction : (noun : any) => boolean = () => false;
-    public countsAs = 0;
-    public score = 0;
-
-    public getScore () {
-        return this.score;
-    }
-
-    constructor (replacer : (noun : any) => boolean, score : number) {
-        this.compareFunction = replacer;
-    }
-
-    public isMatch (noun : any) {
-        return this.compareFunction(noun);
-    }
-
-    public static ANYOF (...acceptableValues) {
-        return new AdaptiveDifferential((noun : any) => {
-            //console.log(acceptableValues, noun);
-            for (let i = 0; i < acceptableValues.length; i++) {
-                if (ContentDifferential.compareNouns(acceptableValues[i], noun)) {
-                    return true;
-                }
-            }
-            return false;
-        }, (new ContentDifferential(...acceptableValues).getScore()));
-    }
-
-    public static FULLYADAPTIVE (...acceptableValues) {
-        let ad = AdaptiveDifferential.ANYOF(...acceptableValues);
-        ad.countsAs = -1;
-        return ad;
-    }
-
-    public static MALE = new AdaptiveDifferential((noun : any) => {
-        if (noun instanceof Humanoid) {
-            return noun.isMale();
-        }
-        return false;
-    }, new ContentDifferential(Humanoid).getScore());
-
-    public static FEMALE = new AdaptiveDifferential((noun : any) => {
-        if (noun instanceof Humanoid) {
-            return noun.isMale();
-        }
-        return false;
-    }, new ContentDifferential(Humanoid).getScore());
-
-    public static MASCULINE = new AdaptiveDifferential((noun : any) => {
-        if (noun instanceof Humanoid) {
-            return noun.getGenderValue().genderValueCorrected <= 50;
-        }
-        return false;
-    }, new ContentDifferential(Humanoid).getScore());
-
-    public static FEMININE = new AdaptiveDifferential((noun : any) => {
-        if (noun instanceof Humanoid) {
-            return noun.getGenderValue().genderValueCorrected >= 50;
-        }
-        return false;
-    }, new ContentDifferential(Humanoid).getScore());
-}

app/World/Classes/ContentPickerOld/Combat/CombatDescription.ts

@@ -1,52 +0,0 @@
-/// <reference path="../ContentDescription.ts" />
-/// <reference path="CombatPokeUnit.ts" />
-/// <reference path="CombatUnit.ts" />
-/**
- * Quick Cheat Sheet of markers!
- * When making a description take these markers into account while describing the action! If a marker describes something
- * please include it if you add it to the description. Example: if you describe the attack as a "heavy hit!", make sure
- * to add the HIGH_DAMAGE marker, we don't want a "heavy hit!" to be displayed for an attack that caused 1 damage.
- *
- * Mandatory Markers - Include only one and clone description for each
- * CombatHit.FULL_DODGE
- * CombatHit.PARTIAL_DODGE
- * CombatHit.FULL_HIT
- *
- * Mandatory Markers - Include only one and clone description for each. These don't show up in FULL_DODGE
- * CombatResult.KNOCKED
- * CombatResult.KNOCKED_OFF
- * CombatResult.KILLED
- *
- * Non-Mandatory Markers - Include at most one per description, none makes a description fit more attacks. These don't show up in FULL_DODGE.
- * CombatDamage.LOW_DAMAGE
- * CombatDamage.MEDIUM_DAMAGE
- * CombatDamage.HIGH_DAMAGE
- */
-class CombatDescription extends ContentDescription {
-    public static DESCRIPTIONS = [];
-
-    public constructor (name : string) {
-        super(name, new ContentGroup());
-        CombatDescription.DESCRIPTIONS.push(this);
-    }
-
-    public setDescriptionFunction (descriptionFor : (actor : any, target : any, weapons : Array<any>, markers : Array<any>) => Say) {
-        let finalFunction = (description : CombatDescription, group : ContentGroup) => {
-            // Combat only has one unit
-            let unit = <CombatUnit> group.getUnit(0);
-            return descriptionFor (unit.getActor().nouns[0], unit.getTarget().nouns[0], unit.getWeapons(), unit.getMarkers());
-        }
-        this.description = finalFunction;
-        return this;
-    }
-
-    public addUnit () {
-        let unit = new CombatUnit();
-        (<ContentGroup> this.group).addUnit(unit);
-        return unit;
-    }
-
-    public static getDescription (target : ContentGroup) {
-        return ContentDescription.pickDescriptions(CombatDescription.DESCRIPTIONS, target);
-    }
-}

app/World/Classes/ContentPickerOld/Combat/CombatMarker.ts

@@ -1,21 +0,0 @@
-/// <reference path="../ContentMarker.ts" />
-/**
- * These are the overall results of the roll. Every attack will have at least one of these.
- * If making a new description, you should clone it for each CombatResult variant.
- */
-class CombatHit extends ContentMarker {
-    public static MISS = new CombatHit("Miss", true);
-    public static HIT = new CombatHit("Hit", true);
-    public static CRITICAL = new CombatHit("Strong Hit", true);
-}
-
-/**
- * These are markers that explain what happened because of the attack.
- * They are mandatory.
- * When making an attack, you should clone the description for each of those, adding this information to it.
- */
-class CombatResult extends ContentMarker {
-    public static KNOCKED = new CombatResult("Target was knocked down by the attack", true);
-    public static KNOCKED_OFF = new CombatResult("Target was knocked off by the attack, becoming unconscious", true);
-    public static KILLED = new CombatResult("Target was killed by this attack", true);
-}

app/World/Classes/ContentPickerOld/Combat/CombatPokeDescription.ts

@@ -1,35 +0,0 @@
-/// <reference path="../ContentDescription.ts" />
-/// <reference path="CombatPokeUnit.ts" />
-/// <reference path="CombatUnit.ts" />
-/**
- * Quick Cheat Sheet of markers!
-
- */
-class CombatPokeDescription extends ContentDescription {
-    public static DESCRIPTIONS = [];
-
-    public constructor (name : string) {
-        super(name, new ContentGroup());
-        CombatPokeDescription.DESCRIPTIONS.push(this);
-    }
-
-    public setDescriptionFunction (descriptionFor : (aggressor : any, target : any, markers : Array<any>) => Say) {
-        let finalFunction = (description : CombatPokeDescription, group : ContentGroup) => {
-            // Combat only has one unit
-            let unit = <CombatPokeUnit> group.getUnit(0);
-            return descriptionFor (unit.getAggressor().nouns[0], unit.getTarget().nouns[0], unit.getMarkers());
-        }
-        this.description = finalFunction;
-        return this;
-    }
-
-    public addUnit () {
-        let unit = new CombatPokeUnit();
-        (<ContentGroup> this.group).addUnit(unit);
-        return unit;
-    }
-
-    public static getDescription (target : ContentGroup) {
-        return ContentDescription.pickDescriptions(CombatPokeDescription.DESCRIPTIONS, target);
-    }
-}

app/World/Classes/ContentPickerOld/Combat/CombatPokeUnit.ts

@@ -1,53 +0,0 @@
-/// <reference path="../ContentUnit.ts" />
-/// <reference path="../../Things/Person.ts" />
-/// <reference path="../../Things/Bodypart/SexHole.ts" />
-/// <reference path="../../Things/Bodypart/SexStick.ts" />
-class CombatPokeUnit extends ContentUnit {
-    private aggressor : ContentDifferential = new ContentDifferential(Person);
-    private target : ContentDifferential = new ContentDifferential(Person);
-    private markers : ContentDifferential = new ContentDifferential();
-
-    public constructor () {
-        super();
-    }
-
-    public setAggressor (it : Thing | typeof Thing) {
-        this.aggressor = new ContentDifferential(it);
-        return this;
-    }
-
-    public getAggressor () {
-        return this.aggressor;
-    }
-
-    public setTarget (it : Thing | typeof Thing) {
-        this.target = new ContentDifferential(it);
-        return this;
-    }
-
-    public getTarget () {
-        return this.target;
-    }
-
-
-    public addMarker (...marker : Array<ContentMarker | AdaptiveDifferential>) {
-        this.markers.addNoun(...marker);
-        return this;
-    }
-
-    public getMarkers () {
-        return [...this.markers.nouns];
-    }
-
-    public getScore () {
-        return this.target.getScore() + this.markers.getScore();
-    }
-
-    public isMatch (cu : CombatPokeUnit) {
-        if (cu instanceof CombatPokeUnit) {
-            return this.target.isMatch(cu.target) && this.aggressor.isMatch(cu.aggressor) &&
-                this.markers.isMatch(cu.markers);
-        }
-        return false;
-    }
-}

app/World/Classes/ContentPickerOld/Combat/CombatUnit.ts

@@ -1,62 +0,0 @@
-/// <reference path="../ContentUnit.ts" />
-/// <reference path="../../Things/Person.ts" />
-/// <reference path="../../Things/Bodypart/SexHole.ts" />
-/// <reference path="../../Things/Bodypart/SexStick.ts" />
-class CombatUnit extends ContentUnit {
-	private actor : ContentDifferential = new ContentDifferential(Person);
-	private target : ContentDifferential = new ContentDifferential(Person);
-	private weapon : ContentDifferential = new ContentDifferential();
-	private markers : ContentDifferential = new ContentDifferential();
-
-	public constructor () {
-		super();
-	}
-
-	public setActor (it : Thing | typeof Thing) {
-		this.actor = new ContentDifferential(it);
-		return this;
-	}
-
-	public getActor () {
-		return this.actor;
-	}
-
-	public setTarget (it : Thing | typeof Thing) {
-		this.target = new ContentDifferential(it);
-		return this;
-	}
-
-	public getTarget () {
-		return this.target;
-	}
-
-	public setWeapon (...it : Array<Thing | typeof Thing>) {
-		this.weapon = new ContentDifferential(...it);
-		return this;
-	}
-
-	public getWeapons () {
-		return [...this.weapon.nouns];
-	}
-
-	public addMarker (...marker : Array<ContentMarker | AdaptiveDifferential>) {
-		this.markers.addNoun(...marker);
-		return this;
-	}
-
-	public getMarkers () {
-		return [...this.markers.nouns];
-	}
-
-	public getScore () {
-		return this.actor.getScore() + this.target.getScore() + this.weapon.getScore() + this.markers.getScore();
-	}
-
-	public isMatch (cu : CombatUnit) {
-		if (cu instanceof CombatUnit) {
-			return this.actor.isMatch(cu.actor) && this.target.isMatch(cu.target) &&
-				this.weapon.isMatch(cu.weapon) && this.markers.isMatch(cu.markers);
-		}
-		return false;
-	}
-}

app/World/Classes/ContentPickerOld/ContentDescription.ts

@@ -1,82 +0,0 @@
-class ContentDescription {
-    public name : string;
-    public group : ContentUnit | ContentGroup;
-    public description : Say | ((description : ContentDescription, group : ContentUnit | ContentGroup) => Say);
-    private saidCount = 0;
-
-    public constructor (name : string, group : ContentUnit | ContentGroup) {
-        this.name = name;
-        this.group = group;
-    }
-
-    public addMarker (marker : any) {
-        if (this.group instanceof ContentGroup) {
-            let markerUnit = new ContentUnit();
-            markerUnit.addCategory(new ContentDifferential(marker))
-            this.group.addUnit(markerUnit);
-        } else if (this.group instanceof ContentUnit) {
-            this.group.addCategory(marker);
-        }
-    }
-
-    public getScore () {
-        return (this.group).getScore();
-    }
-
-    public getDescription (group : ContentUnit | ContentGroup) : Say {
-        this.saidCount++;
-        if (typeof this.description == "function") {
-            return this.description(this, group);
-        }
-        return this.description;
-    }
-
-    public setDescription (description : Say | string | ((description : ContentDescription, group : ContentUnit | ContentGroup) => Say) ) {
-        if (!(description instanceof Say)) {
-            this.description = new Say(description);
-        } else {
-            this.description = description;
-        }
-        return this;
-    }
-
-    public static pickDescriptions (cda : Array<ContentDescription>, target : ContentGroup | ContentUnit) : Array<Say> {
-        let a = cda.slice();
-        let groups = [];
-        for (let i = 0; i < a.length; i++) {
-            let randomIndex = Math.floor(Math.random() * (a.length - i)) + i;
-            let temp = a[i];
-            a[i] = a[randomIndex];
-            a[randomIndex] = temp;
-        }
-
-        // After shuffling the list, descriptions with the highest scores go at the top, and between those the ones with the lowest saidCounts go first
-        // If multiple descriptions have the same score/saidCount, they are picked randomly due to the previous shuffling.
-        a.sort((a : ContentDescription, b : ContentDescription) => {
-            // Division by saidCount for now, to increase rotativity of descriptions
-            // Reduce precision on final number to decrease the likelihood of printing the same descriptions always in the same order
-            let precision = 5;
-            let scoreA = Math.floor(precision * a.getScore() / (a.saidCount + 1)) / precision;
-            let scoreB = Math.floor(precision * b.getScore() / (b.saidCount + 1)) / precision;
-            if (scoreA != scoreB) return scoreB - scoreA;
-            return 0;
-        });
-
-        a.forEach(description => {
-            groups.push(description.group);
-        });
-
-        let matches = (<any> target).matchAgainst(<any> groups);
-        if (matches != undefined) {
-            let result = [];
-            matches.forEach(i => {
-                result.push(a[i].getDescription(target));
-                result.push(new Say(" "));
-            });
-            return result;
-        } else {
-            console.warn("No description available for", target);
-            return [new Say("Warning: No description available for the current situation. Please report so it can be corrected.")];
-        }
-    }
-}

app/World/Classes/ContentPickerOld/ContentDifferential.ts

@@ -1,163 +0,0 @@
-interface ContentDifferentialComparisonResult {
-    matching : Array<Thing | typeof Thing | ContentDifferential | ContentMarker>;
-    unmatched : Array<Thing | typeof Thing | ContentDifferential | ContentMarker>;
-}
-
-class ContentDifferential {
-    public nouns : Array<Thing | typeof Thing | ContentDifferential | ContentMarker> = [];
-    public score : number = 0;
-
-    public constructor (...nouns : Array<any>) {
-        this.addNoun(...nouns);
-    }
-
-    public addNoun (...nouns : Array<any>) {
-        nouns.forEach(noun => {
-            if (noun != undefined) {
-                this.nouns.push(noun);
-            }
-        });
-        this.score = this.getScore();
-        return this;
-    }
-
-    public getNouns () {
-        return this.nouns;
-    }
-	
-	public replaceNouns (...nouns : Array<any>) {
-		this.nouns = nouns;
-		return this;
-	}
-
-    public isMatch (cd : ContentDifferential, allowPartial = false) {
-        let check = this.getUnmatched(cd);
-        if ((allowPartial || (check.unmatched.length) <= 0) && check.matching.length == 0) {
-            return true;
-        } else if ((allowPartial || (check.unmatched.length) <= 0) && check.matching.length > 0) {
-            for (let i = 0; i < check.matching.length; i++) {
-                if (!(check.matching[i] instanceof AdaptiveDifferential && (<AdaptiveDifferential> <unknown> check.matching[i]).countsAs == -1)) {
-                    return false;
-                }
-                return true;
-            }
-        } else if (check.matching.length == 0) {
-            for (let i = 0; i < check.unmatched.length; i++) {
-                if (!(check.unmatched[i] instanceof ContentMarker)) {
-                    return false;
-                } else {
-                    if ((<ContentMarker> check.unmatched[i]).isImportant()) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-
-    public getUnmatched (cd : ContentDifferential) : ContentDifferentialComparisonResult {
-        let unmatched = cd.nouns.slice();
-        let matching = this.nouns.slice();
-        for (let i = matching.length - 1; i >= 0; i--) {
-            for (let k = unmatched.length - 1; k >= 0; k--) {
-                if (ContentDifferential.compareNouns(matching[i], unmatched[k])) {
-                    unmatched.splice(k, 1);
-                    matching.splice(i, 1);
-                    break;
-                }
-            }
-        }
-        return {
-            matching : matching,
-            unmatched : unmatched
-        };
-    }
-
-    public getScore () {
-        let highest = 0;
-
-        this.nouns.forEach((noun) => {
-            highest += ContentDifferential.getNounLevel(noun);
-        });
-
-        return highest;
-    }
-
-    public static getNounLevel (noun : Thing | typeof Thing | ContentDifferential | ContentMarker) {
-        if (noun == undefined || noun == null) {
-            return 0;
-        } else if (noun instanceof AdaptiveDifferential) {
-            return noun.getScore();
-        } else if (typeof noun == "function") {
-            if (<any>noun.prototype instanceof Thing) {
-                let specifity = 2; // Vague Thing
-                let parentClass = Object.getPrototypeOf(noun);
-                while (parentClass != Thing) {
-                    specifity += 0.1;
-                    parentClass = Object.getPrototypeOf(parentClass);
-                }
-                return specifity;
-            } else {
-                return 2.5; // It's not a "Thing", so it's probably a weird class, which is kind of specific
-            }
-        } else if (noun instanceof Thing) {
-            return 4; // Specific thing
-        } else if (noun instanceof ContentDifferential) {
-            return 1; // Minor thing
-        } else {
-            return 0.5;
-        }
-    }
-
-    public static compareNouns (a : Thing | typeof Thing | ContentDifferential | ContentMarker, b : Thing | typeof Thing | ContentDifferential | ContentMarker) {
-        if (a == undefined || a == null) {
-            return true;
-        }
-        if (a instanceof AdaptiveDifferential) {
-            //console.log(a, b, a.isMatch(b));
-            return a.isMatch(b);
-        } else if (typeof a == "function") {
-            // b must inherit a or be a
-            return b == a || b instanceof a || (typeof b == "function" && (<any>b).prototype instanceof a)
-        } else if (a instanceof Thing) {
-            // b must be a
-            return b == a;
-        }
-        return a === b;
-    }
-
-    public static isMatch (matchFrom : Array<ContentDifferential>, matchAgainst : Array<ContentDifferential>) {
-        let unmatched = matchAgainst.slice();
-        let matching = matchFrom.slice();
-        for (let i = matching.length - 1; i >= 0; i--) {
-            for (let k = unmatched.length - 1; k >= 0; k--) {
-                if (matching[i].isMatch(unmatched[k])) {
-                    unmatched.splice(k, 1);
-                    matching.splice(i, 1);
-                    break;
-                }
-            }
-        }
-        if (unmatched.length == 0 && matching.length == 0) {
-            return true;
-        } else if (unmatched.length == 0) {
-            // Check if the only thing missing are unimportant ContentMarkers
-            for (let i = 0; i < matching.length; i++) {
-                let nouns = matching[i].getNouns();
-                for (let k = 0; k < nouns.length; k++) {
-                    if (!(nouns[k] instanceof ContentMarker)) {
-                        return false;
-                    } else {
-                        if ((<ContentMarker> nouns[k]).isImportant()) {
-                            return false;
-                        }
-                    }
-                }
-            }
-            // Nothing important found
-            return true;
-        }
-        return false;
-    }
-}

app/World/Classes/ContentPickerOld/ContentGroup.ts

@@ -1,100 +0,0 @@
-enum ContentGroupMatch {
-    NO_MATCH,
-    PARTIAL_MATCH,
-    PERFECT_MATCH
-}
-
-interface ContentGroupMatchResult {
-    type : ContentGroupMatch;
-    unmatched : Array<ContentUnit>;
-}
-
-class ContentGroup {
-    private units : Array<ContentUnit> = [];
-    private matching : Array<ContentUnit>;
-
-    constructor (...units : Array<ContentUnit>) {
-        units.forEach(unit => {
-            this.addUnit(unit);
-        })
-    }
-
-    public addUnit (unit : ContentUnit) {
-        this.units.push(unit);
-        return this;
-    }
-
-    public addDifferentials (...differentials : Array<any>) {
-        let unit = new ContentUnit();
-        unit.addCategory(...differentials);
-        this.addUnit(unit);
-        return this;
-    }
-
-    public reset () {
-        this.matching = this.units.slice();
-    }
-	
-	public isMatching () {
-		return this.matching.length;
-	}
-
-    public setMatching (matching : Array<ContentUnit>) {
-        this.matching = matching;
-    }
-
-    public isMatch (cg : ContentGroup) : ContentGroupMatchResult {
-        let unmatched = cg.matching.slice();
-        let matching = this.units.slice();
-
-        for (let i = matching.length - 1; i >= 0; i--) {
-            for (let k = unmatched.length - 1; k >= 0; k--) {
-                if (matching[i].isMatch(unmatched[k])) {
-                    unmatched.splice(k, 1);
-                    matching.splice(i, 1);
-                    break;
-                }
-            }
-        }
-
-        return {
-            type : matching.length > 0 ? ContentGroupMatch.NO_MATCH :
-                    unmatched.length == 0 ? ContentGroupMatch.PERFECT_MATCH :
-                        ContentGroupMatch.PARTIAL_MATCH,
-            unmatched : unmatched
-        }
-    }
-
-    public getScore () {
-        let score = 0;
-        this.units.forEach(unit => {
-            score += unit.getScore();
-        });
-
-        return score;
-    }
-
-    public matchAgainst (a : Array<ContentGroup>) : Array<number> {
-        let matches = [];
-        this.reset();
-        for (let i = 0; i < a.length; i++) {
-            let match = a[i].isMatch(this);
-            if (match.type != ContentGroupMatch.NO_MATCH) {
-                matches.push(i);
-                this.setMatching(match.unmatched);
-            }
-            if (!this.isMatching()) {
-                return matches;
-            }
-        }
-        return undefined;
-    }
-
-    public getLength () {
-        return this.units.length;
-    }
-
-    public getUnit (n : number) {
-        return this.units[n];
-    }
-}

app/World/Classes/ContentPickerOld/ContentMarker.ts

@@ -1,13 +0,0 @@
-class ContentMarker {
-    public name : string;
-    private readonly important : boolean = false;
-
-    constructor (name : string, important? : boolean) {
-        this.name = name;
-        this.important = important == true;
-    }
-
-    public isImportant () {
-        return this.important;
-    }
-}

app/World/Classes/ContentPickerOld/ContentUnit.ts

@@ -1,30 +0,0 @@
-/// <reference path="ContentDifferential.ts" />
-class ContentUnit {
-    public categories : Array<ContentDifferential> = [];
-
-    public addCategory (...nouns : Array<Thing | typeof Thing | ContentDifferential>) {
-        this.categories.push(new ContentDifferential(...nouns));
-        return this;
-    }
-
-    public isMatch (cu : ContentUnit) {
-        return ContentDifferential.isMatch(this.categories, cu.categories);
-    }
-
-    public getScore () {
-        let score = 0;
-        this.categories.forEach(diff => {
-            score += diff.score;
-        });
-
-        return score / this.categories.length;
-    }
-
-    public matchAgainst (a : Array<ContentUnit>) : Array<number> {
-        for (let i = 0; i < a.length; i++) {
-            if (a[i].isMatch(this)) {
-                return [i];
-            }
-        }
-    }
-}

app/World/Classes/ContentPickerOld/Fucking/FuckingDescription.ts

@@ -1,19 +0,0 @@
-/// <reference path="../ContentDescription.ts" />
-class FuckingDescription extends ContentDescription {
-    public static DESCRIPTIONS = [];
-
-    public constructor (name : string) {
-        super(name, new ContentGroup());
-        FuckingDescription.DESCRIPTIONS.push(this);
-    }
-
-    public addUnit () {
-        let unit = new FuckingUnit();
-        (<ContentGroup> this.group).addUnit(unit);
-        return unit;
-    }
-
-    public static getDescription (target : ContentGroup) {
-        return ContentDescription.pickDescriptions(FuckingDescription.DESCRIPTIONS, target);
-    }
-}

app/World/Classes/ContentPickerOld/Fucking/FuckingMarker.ts

@@ -1,58 +0,0 @@
-/// <reference path="../ContentMarker.ts" />
-/**
- * CHEAT SHEET FOR FUCKING MARKERS
- *
- * Mandatory if present -   These may all appear at once or separatedly! Separated is always rarer, so you can get away with less descriptions (Most enemies will start and finish in a single turn)
- *                          CUM_END will always appear together with Cumming.
- * FuckingState.CUM_START
- * FuckingState.CUMMING
- * FuckingState.CUM_END
- *
- * Mandatory if present - these always accompany the ones above, they never appear without at least one of the ones above. They might be both at once, but very few enemies do that so always check the enemy first (both at once = messy)
- * FuckingState.CUM_INSIDE
- * FuckingState.CUM_OUTSIDE
- *
- * Mandatory if present - These may all appear at once or separatedly! Multiples is always rarer, so you can get away with less descriptions. (Only a special enemy would both insert and finish and remove in the same turn)
- * FuckingState.PENETRATING
- * FuckingState.REMOVING
- *
- * Mandatory if present - Only one of these is ever active
- * FuckeePosition.STANDING
- * FuckeePosition.ALLFOURS
- *
- * Optional - Only one of these is ever active
- * FuckingStyle.GENTLE
- * FuckingStyle.ROUGH
- *
- *
- * TO MATCH ANIMATIONS:
- * - Anything fucking the crotch does so from BEHIND. Only ignore this if you know for a fact that there are special animations, and then all the other descriptions must follow.
- *
- * Examples:
- * {
- *     Fucking Unit: Orc is Fucker, Player is Fuckee, Orc Penis is Stick, Player Vagina is Hole, Markers: FuckingStyle.GENTLE - FuckeePosition.STANDING
- * }
- */
-
-class FuckingStyle extends ContentMarker {
-    public static GENTLE = new FuckingStyle("Gentle", false);
-    public static ROUGH = new FuckingStyle("Rough", false);
-}
-
-class FuckingState extends ContentMarker {
-    public static PENETRATING = new FuckingState("Penetration Start", true);
-    public static REMOVING = new FuckingState("Removing Stick", true);
-    public static SPEEDING_UP = new FuckingState("Speeding up",true);
-
-    public static CUM_START = new FuckingState("Started Cumming", true);
-    public static CUMMING = new FuckingState("Cumming", true);
-    public static CUM_END = new FuckingState("Finished Cumming", true);
-
-    public static CUM_INSIDE = new FuckingState("Cum Inside", true);
-    public static CUM_OUTSIDE = new FuckingState("Cum Outside", true);
-}
-
-class FuckeePosition extends ContentMarker {
-    public static STANDING = new FuckingStyle("Standing");
-    public static ALLFOURS = new FuckingStyle("On All Fours");
-}

app/World/Classes/ContentPickerOld/Fucking/FuckingUnit.ts

@@ -1,52 +0,0 @@
-/// <reference path="../ContentUnit.ts" />
-/// <reference path="../../Things/Person.ts" />
-/// <reference path="../../Things/Bodypart/SexHole.ts" />
-/// <reference path="../../Things/Bodypart/SexStick.ts" />
-class FuckingUnit extends ContentUnit {
-    private fucker : ContentDifferential = new ContentDifferential(Person);
-    private fucked : ContentDifferential = new ContentDifferential(Person);
-    private hole : ContentDifferential = new ContentDifferential(SexHole);
-    private stick : ContentDifferential = new ContentDifferential(SexStick);
-    private markers : ContentDifferential = new ContentDifferential();
-
-    public constructor () {
-        super();
-    }
-
-    public setFucker (it : Thing | typeof Thing) {
-        this.fucker = new ContentDifferential(it);
-        return this;
-    }
-
-    public setFucked (it : Thing | typeof Thing) {
-        this.fucked = new ContentDifferential(it);
-        return this;
-    }
-
-    public setHole (it : Thing | typeof Thing) {
-        this.hole = new ContentDifferential(it);
-        return this;
-    }
-
-    public setStick (it : Thing | typeof Thing) {
-        this.stick = new ContentDifferential(it);
-        return this;
-    }
-
-    public addMarker (marker : ContentMarker) {
-        this.markers.addNoun(marker);
-        return this;
-    }
-
-    public getScore () {
-        return this.fucker.getScore() + this.fucked.getScore() + this.hole.getScore() + this.stick.getScore() + this.markers.getScore();
-    }
-
-    public isMatch (fu : FuckingUnit) {
-        if (fu instanceof FuckingUnit) {
-            return this.fucker.isMatch(fu.fucker) && this.fucked.isMatch(fu.fucked) &&
-                this.hole.isMatch(fu.hole) && this.stick.isMatch(fu.stick) && this.markers.isMatch(fu.markers);
-        }
-        return false;
-    }
-}

app/World/WorldState.ts

@@ -9,7 +9,7 @@
 module WorldState {
     var worldTurn : number = 0;
     var playerTurn : number = 0;
-    export var player : Humanoid = new Humanoid({isMale : false});
+    export var player : Humanoid = new Humanoid({isMale : false, name : "Player", unique : true});
 
     player.description = Humanoid.getPlayerDescription;