code:
package classes
{
	import flash.utils.Proxy;
	import flash.utils.flash_proxy;
	import flash.utils.Dictionary

	// This is a special class that immitates a array/dictionary, and
	// yet has some special behaviour to make it look & act like any arbitrary aray value
	// is pre-initialized to 0.
	public dynamic class DefaultDict extends Proxy
	{
		// Actual key<->value pairs are stored in _dict
		private var _dict:Object;

		// Set to true to print any access to defaultDict members
		private var debugPrintDict:Boolean = false;

		public function DefaultDict()		// Constructor
		{
			_dict = new Object();
			if (debugPrintDict) trace("Instantiating default dict class");
		}

		// used to determine status of the query 'name in defaultDict'.
		// Since we want to *look* like have any arbitrary key, we always return true.
		override flash_proxy function hasProperty(name:*):Boolean
		{
			if (debugPrintDict) trace("hasProperty", name);
			return true;
		}

		// called when someone requests defaultDict[name] or defaultDict.name
		// we have a special case to override the query for defaultDict.length, since
		// that is used for determining how many flags the save/load mechanism iterates over.
		// I'm going to update that to properly iterating over each item in the save eventually
		// but this makes it work as a stop-gap measure
		override flash_proxy function getProperty(name:*):*
		{
			if (debugPrintDict) trace("getProperty Called");
			if (name == "length")
			{
				if (debugPrintDict) trace("Querying array length. Faking out retVal");
				return 4000;
			}

			// If we have name as a key in _dict, return _dict[name]. Else, return 0
			if (name in _dict)
			{
				if (debugPrintDict) trace("Flag " + name + " being accessed. Value = " + _dict[name]);
				return _dict[name];
			}
			else
			{
				if (debugPrintDict) trace("Unset Flag " + name + " being accessed.");
				return 0;
			}
		}

		// Overrides any attempt to set a class member or indice (defaultDict[name] = x or defaultDict.name = x)
		// If x == 0, it removes {name} from _dict if it's present, otherwise does nothing. Else, it sets _dict[name] = x
		override flash_proxy function setProperty(name:*, value:*):void
		{
			if (value != 0)
			{
				if (debugPrintDict) trace("setProperty ", name, value);
				_dict[name] = value;
			}
			else
				if (name in _dict)
				{
					if (debugPrintDict) trace("setProperty " + name + " to " + value + " Deleting key");
					delete _dict[name];
				}
				else
					if (debugPrintDict) trace("setProperty " + name + " to " + value + " Ignoring");
		}

		// callProperly is called when functions are called on instances of defaultDict,
		// e.g. defaultDict.push(), etc...
		// Since we don't have an array length, per se, we just swallow instances of push.
		// otherwise, we just apply the called function name to _dict.
		override flash_proxy function callProperty(methodName:*, ... args):*
		{
			if (debugPrintDict) trace("call Property ", methodName);
			if (String(methodName) == "push")
			{
				if (debugPrintDict) trace("Doing nothing (this ain't an array anymore!)");
			}
			else
			{
				var res:*;
				res = _dict[methodName].apply(_dict, args);
				return res;
			}
		}

		// you have to implement object management bits yourself, since unfortunately the proxy
		// object doesn't have default stuff you can just override where you want special behaviour
		// As such, the following functions just make defaultDict iterable, and manage removing
		// things, etc...

		//public function getIteratorObj():IIterator
		//{
		//	return IIterator(_dict);
		//
		//}

		override flash_proxy function deleteProperty(name:*):Boolean
		{
			if (debugPrintDict) trace("deleteProperty", name);
			return delete _dict[name];
		}

		override flash_proxy function nextName(index:int):String
		{
			if (debugPrintDict) trace("nextName", index);
			return String(index - 1);
		}

		override flash_proxy function nextValue(index:int):*
		{
			if (debugPrintDict) trace("nextValue", index);
			return _dict[index - 1];
		}

		override flash_proxy function nextNameIndex(index:int):int
		{

			if (debugPrintDict) trace("nextNameIndex ", index);
			if (!(index in _dict))
			{
				if (debugPrintDict) trace("Returning 0");
				return 0;
			}
			return index + 1;
		}

	}
}

license: unknown


code:
package classes
{
	/**
	 * Class to keep track of, and control of each embryo the game manages.
	 */
	public class Embryo
	{
		private var _fatherID:int;

		private var _strength:int;
		private var _tough:int;
		private var _speed:int;
		private var _intellegence :int;
		private var _libido:int;
		private var _sensitivity:int;
		private var _corruption:int;

		private var _flagIncubation:int;

		//Not implemented yet
		//Still need a way to add indivual or groups of events.
		private var _eventValue:Vector.< Vector.<int> >;

		private var _embryoCorruption:int; //This is how much corruption the child has taken since or even including when the character got knocked up.

		public get FatherID():int{return _fatherID;}
		public set FatherID(value:int){_fatherID = value;}

		public get Strength():int{return _strength;}
		public set Strength(value:int){_strength = value;}

		public get Tough():int{return _tough;}
		public set Tough(value:int){_tough = value;}

		public get Speed():int{return _speed;}
		public set Speed(value:int){_speed = value;}

		public get Intellegence():int{return _intellegence;}
		public set Intellegence(value:int){_intellegence = value;}

		public get Libido():int{return _libido;}
		public set Libido(value:int){_libido = value;}

		public get Sensitivity():int{return _sensitivity;}
		public set Sensitivity(value:int){_sensitivity = value;}

		public get Corruption():int{return _corruption;}
		public set Corruption(value:int){_corruption = value;}

		public get Stats():int{return new int{Strength, Tough,Speed,Intellegence,Libido,Sensitivity,Corruption}}
		public set Stats(value:int[])

		public get FlagIncubation():int{return _flagIncubation;}
		public set FlagIncubation(value:int){_flagIncubation = value;}

		//Need to work out the logic for this still.
		public get EventValue(): Vector.< Vector.<int> >{return this._eventValue;}
		public set EventValue(value:Vector.< Vector.<int> >){_eventValue = value;}

		public get EmbryoCorruption():int{return _embryoCorruption;}
		public set EmbryoCorruption(value:int){_embryoCorruption = value;}

		{
			if(value.length > 6)
			{
				Strength = value[0];
				Tough = value[1];
				Speed = value[2];
				Intellegence = value[3];
				Libido = value[4];
				Sensitivity = value[5];
				Corruption = value[6];
			}
		}
		public function Embryo(fatherID:int, stats:int[], flagIncubation:int)
		{
			this._fatherID = FatherID; // sets the type of creature this is.
			this.Stats = stats; //sets the stats used to figure out player bonus
			this.flagIncubation = flagIncubation; //Quite honestly.... NO CLUE.
		}

	}

}


code:
package classes
{
	/**
	 * Enum Class. http://scottbilas.com/blog/ultimate-as3-fake-enums/
	 * @author scottbilas
	 */
	import flash.utils.*;

	// This whole thing is a fucking abomination and it needs to die in a horrible fucking fire.
	public /*abstract*/class Enum implements IExternalizable
	{
		public function get Name():String
		{
			return _name;
		}

		public function get Index():int
		{
			return _index;
		}

		public /*override*/function toString():String
		{
			return Name;
		}

		public static function GetConstants(i_type:Class):Array
		{
			var constants:EnumConstants = _enumDb[getQualifiedClassName(i_type)];
			if (constants == null)
				return null;

			// return a copy to prevent caller modifications
			return constants.ByIndex.slice();
		}

		public static function ParseConstant(i_type:Class, i_constantName:String, i_caseSensitive:Boolean = false):Enum
		{
			var constants:EnumConstants = _enumDb[getQualifiedClassName(i_type)];
			if (constants == null)
				return null;

			var constant:Enum = constants.ByName[i_constantName.toLowerCase()];
			if (i_caseSensitive && (constant != null) && (i_constantName != constant.Name))
				return null;

			return constant;
		}

		public static function ParseConstantByIndex(i_type:Class, i_constantIndex:int):Enum
		{
			var constants:EnumConstants = _enumDb[getQualifiedClassName(i_type)];
			if (constants == null)
				return null;

			var constant:Enum = constants.ByIndex[i_constantIndex];
			if (constant != null && i_constantIndex != constant.Index)
				return null;

			return constant;
		}

		/*-----------------------------------------------------------------*/

		/*protected*/
		function Enum()
		{
			var typeName:String = getQualifiedClassName(this);
			var db:* = _enumDb;

			// discourage people new'ing up constants on their own instead
			// of using the class constants
			if (_enumDb[typeName] != null)
			{
				//throw new Error("Enum constants can only be constructed as static consts " + "in their own enum class " + "(bad type='" + typeName + "')");
			}

			if (_enumDb[typeName] == null)
			{
				// if opening up a new type, alloc an array for its constants
				var constants:Array = _pendingDb[typeName];
				if (constants == null)
					_pendingDb[typeName] = constants = [];

				// record
				_index = constants.length;
				constants.push(this);
			}
		}

		protected static function initEnum(i_type:Class):void
		{
			var typeName:String = getQualifiedClassName(i_type);

			// can't call initEnum twice on same type (likely copy-paste bug)
			if (_enumDb[typeName] != null)
			{
				//throw new Error("Can't initialize enum twice (type='" + typeName + "')");
			}

			if (_enumDb[typeName] == null)
			{
				// no constant is technically ok, but it's probably a copy-paste bug
				var constants:Array = _pendingDb[typeName];
				if (constants == null)
				{
					throw new Error("Can't have an enum without any constants (type='" + typeName + "')");
				}

				// process constants
				var type:XML = flash.utils.describeType(i_type);
				for each (var constant:XML in type.constant)
				{
					// this will fail to coerce if the type isn't inherited from Enum
					var enumConstant:Enum = i_type[constant.@name];

					// if the types don't match then probably have a copy-paste error.
					// this is really common so it's good to catch it here.
					var enumConstantType:* = Object(enumConstant).constructor;
					if (enumConstantType != i_type)
					{
						throw new Error("Constant type '" + enumConstantType + "' " + "does not match its enum class '" + i_type + "'");
					}

					enumConstant._name = constant.@name;
				}

				// now seal it
				_pendingDb[typeName] = null;
				_enumDb[typeName] = new EnumConstants(constants);
			}
		}

		public function writeExternal(outData:IDataOutput):void
		{
			outData.writeInt(_index);
		}

		public function readExternal(inData:IDataInput):void
		{
			_index = inData.readInt();
		}

		private var _name:String = null;
		private var _index:int = -1;

		private static var _pendingDb:Object = {}; // typename -> [constants]
		private static var _enumDb:Object = {}; // typename -> EnumConstants
	}
}

// private support class
class EnumConstants
{
	//AS3 won't find Enum if it isn't in the default package
	import classes.Enum;

	public function EnumConstants(i_byIndex:Array)
	{
		ByIndex = i_byIndex;

		for (var i:int = 0; i < ByIndex.length; ++i)
		{
			var enumConstant:Enum = ByIndex[i];
			ByName[enumConstant.Name.toLowerCase()] = enumConstant;
		}
	}

	public var ByIndex:Array;
	public var ByName:Object = {};
}


code:
package classes
{
	import classes.Scenes.Achievements;
	import coc.view.CoCButton;
	import coc.view.MainView;
	import flash.display.Stage;
	import flash.display.StageQuality;
	import flash.text.TextField;
	import flash.text.TextFormat;
	import classes.GlobalFlags.kFLAGS;

	/*Class goal.
	 *  Take the Fetish flag, figure out different combinations of fetishes the player has given a single number variable.
	 *
	 * Originally, COC did a simple if statement to check if the fetish desired and previous fetishes were aquired.
	 *
	 * The new system takes a bit value and gives each fetish a bit to compare.
	 * 00000000 = 0 is fetishless or default
	 * 00000101 = 5 is No combat + exhibistionist but not bondage
	 *
	 *
	 * Possible problem. Engine is using a signed integer, but really we should be used unsigned for this. The logic should still be the same, it will just be annoying to wrap my head around.
	 */

	public class FetishManager
	{
		public static const DEFAULT_STATE		:uint = 0;

		public static const FETISH_EXHIBITION 	:uint = 1 << 0;  //00000001 = 1
		public static const FETISH_BONDAGE		:uint = 1 << 1;  //00000010 = 2
		public static const FETISH_NO_COMBAT	:uint = 1 << 2;  //00000100 = 4
		public static const FETISH_A			:uint = 1 << 3;  //00001000 = 8
		public static const FETISH_B			:uint = 1 << 4;  //00010000 = 16
		public static const FETISH_C			:uint = 1 << 5;  //00100000 = 32
		public static const FETISH_D			:uint = 1 << 6;  //01000000 = 64
		public static const FETISH_E			:uint = 1 << 7;  //10000000 = 128
		public static const FETISH_F			:uint = 1 << 8;  //00000001 00000000 = 256
		public static const FETISH_G			:uint = 1 << 9;  //00000010 00000000 = 512
		public static const FETISH_H			:uint = 1 << 10; //00000100 00000000 = 1,024
		public static const FETISH_I			:uint = 1 << 11; //00001000 00000000 = 2,048
		public static const FETISH_J			:uint = 1 << 12; //00010000 00000000 = 4,096
		public static const FETISH_K			:uint = 1 << 13; //00100000 00000000 = 8,192

		//the max value for non perk fetish. Use it like length with array.
		//TODO Test this. Logic suggest it will work, but i'm not sure.
		public static const MAX_FETISH			:uint =
		FETISH_EXHIBITION + FETISH_BONDAGE + FETISH_NO_COMBAT;// +
		//FETISH_A +FETISH_B + FETISH_C + FETISH_D + FETISH_E + FETISH_F +
		//FETISH_G + FETISH_H + FETISH_I + FETISH_J + FETISH_K;

		public function get Fetish():uint {
			if (kFLAGS[kFLAGS.PC_FETISH] == undefined) {
				trace("Reset forced");
				reset();
			}
			return kFLAGS[kFLAGS.PC_FETISH];
		}

		public function set Fetish(value:uint):void{
			kFLAGS[kFLAGS.PC_FETISH] = value;
		}

		//this will true off or on the fettishes passed in using a XOR opperator
		public function flipFetish(flipFetish:uint):void{
			this.Fetish =  this.Fetish^flipFetish

		}

		//this will give fettishes passed in using a OR opperator
		public function giveFetish(giveFetish:uint):void{
			this.Fetish =  this.Fetish|giveFetish
		}

		//this will remove fettishes passed in by using a AND opperator then fliping the paramenters bits.
		//
		public function removeFetish(removeFetish:uint):void{
			this.Fetish =  this.Fetish&~removeFetish
		}

		//reset the value to 0, no fetish, 00000000
		public function reset():void{
			this.Fetish = 0;
		}

		//checks if the combind value of the current fetish, and the to be compared fetish equal the current fetish.
		//if the to be compared fetish lacks or has fetishes the current fetish has, then it will still return true. The current fetish value will true true the flags the compared fetish lacks making it the same number.
		//if the to be comapred fetish has fetishes the current fetish does not, then the number will be different, causing the return result to be false.
		//this does not compare abosule numbers. For instances it wont compare if the player only has no combat fetish. But it will compare if it has no combat fetish; even if the characte has bondage fetish.
		public function compare (compareFetish:uint):Boolean{
			return this.Fetish == (this.Fetish | compareFetish); //initalizes the value that both the fetish, and to be fetish have in common. Then checks if this new number is equal to the original fetish being checked.
		}
	}
}


code:
//Achievements ahoy!

package classes.GlobalFlags
{
	public class kACHIEVEMENTS
	{
		//Storyline Achievements (000-009)
		public static const STORY_NEWCOMER:int					= 000; //Enter the realm of Mareth.
		public static const STORY_MARAE_SAVIOR:int				= 001; //Complete Marae’s quest.
		public static const STORY_ZETAZ_REVENGE:int				= 002; //Defeat Zetaz and obtain the map.
		public static const STORY_FINALBOSS:int					= 003; //Defeat Lethice.
		public static const UNKNOWN_ACHIEVEMENT_004:int			= 004;
		public static const UNKNOWN_ACHIEVEMENT_005:int			= 005;
		public static const UNKNOWN_ACHIEVEMENT_006:int			= 006;
		public static const UNKNOWN_ACHIEVEMENT_007:int			= 007;
		public static const UNKNOWN_ACHIEVEMENT_008:int			= 008;
		public static const UNKNOWN_ACHIEVEMENT_009:int			= 009;

		//Zone Achievements (010-029)
		public static const ZONE_EXPLORER:int					= 010; //Discover every zone.
		public static const ZONE_SIGHTSEER:int					= 011; //Discover every place.
		public static const ZONE_WHERE_AM_I:int					= 012; //Explore for the first time.
		public static const ZONE_FOREST_RANGER:int				= 013; //Explore the forest 100 times.
		public static const ZONE_VACATIONER:int					= 014; //Explore the lake 100 times.
		public static const ZONE_DEHYDRATED:int					= 015; //Explore the desert 100 times.
		public static const ZONE_MOUNTAINEER:int				= 016; //Explore the mountain 100 times.
		public static const ZONE_WE_NEED_TO_GO_DEEPER:int		= 017; //Explore the deepwoods 100 times.
		public static const ZONE_ROLLING_HILLS:int				= 018; //Explore the plains 100 times.
		public static const ZONE_WET_ALL_OVER:int				= 019; //Explore the swamp 100 times.
		public static const ZONE_LIGHT_HEADED:int				= 020; //Explore the high mountain 100 times.
		public static const ZONE_ALL_MURKY:int					= 021; //Explore the bog 100 times.
		public static const ZONE_FROZEN:int						= 022; //Explore the glacial rift 100 times.
		public static const ZONE_ARCHAEOLOGIST:int				= 023; //Visit the town ruins 15 times.
		public static const ZONE_FARMER:int						= 024; //Visit the farm 30 times.
		public static const ZONE_SEA_LEGS:int					= 025; //Use the boat 15 times.
		public static const ZONE_ROASTED:int					= 026; //Explore the volcanic crag 50 times.
		public static const UNKNOWN_ACHIEVEMENT_027:int			= 027;
		public static const UNKNOWN_ACHIEVEMENT_028:int			= 028;
		public static const UNKNOWN_ACHIEVEMENT_029:int			= 029;

		//Level Achievements (030-039)
		public static const LEVEL_LEVEL_UP:int					= 030; //Level 2
		public static const LEVEL_NOVICE:int					= 031; //Level 5
		public static const LEVEL_APPRENTICE:int				= 032; //Level 10
		public static const LEVEL_JOURNEYMAN:int				= 033; //Level 15
		public static const LEVEL_EXPERT:int					= 034; //Level 20
		public static const LEVEL_MASTER:int					= 035; //Level 30
		public static const LEVEL_GRANDMASTER:int				= 036; //Level 40
		public static const LEVEL_ILLUSTRIOUS:int				= 037; //Level 50
		public static const LEVEL_OVERLORD:int					= 038; //Level 60
		public static const LEVEL_ARE_YOU_A_GOD:int				= 039; //Level 100 (shadow achievement)

		//Population Achievements (040-049)
		public static const POPULATION_FIRST:int				= 040; //Population 2
		public static const POPULATION_HAMLET:int				= 041; //Population 5
		public static const POPULATION_VILLAGE:int				= 042; //Population 10
		public static const POPULATION_TOWN:int					= 043; //Population 25
		public static const POPULATION_CITY:int					= 044; //Population 100
		public static const POPULATION_METROPOLIS:int			= 045; //Population 250
		public static const POPULATION_MEGALOPOLIS:int			= 046; //Population 500
		public static const POPULATION_CITY_STATE:int			= 047; //Population 1,000 (shadow achievement)
		public static const POPULATION_KINGDOM:int				= 048; //Population 2,500 (shadow achievement)
		public static const POPULATION_EMPIRE:int				= 049; //Population 5,000 (shadow achievement)

		//Time Achievements (050-059)
		public static const TIME_MONTH:int						= 050; //30 days
		public static const TIME_HALF_YEAR:int					= 051; //180 days
		public static const TIME_ANNUAL:int						= 052; //365 days
		public static const TIME_BIENNIAL:int					= 053; //730 days
		public static const TIME_TRIENNIAL:int					= 054; //1095 days
		public static const TIME_LONG_HAUL:int					= 055; //1825 days
		public static const TIME_DECADE:int						= 056; //3650 days
		public static const TIME_CENTURY:int					= 057; //36,500 days (shadow achievement)
		public static const TIME_MILLENNIUM:int					= 058;
		public static const TIME_TRAVELLER:int					= 059;

		//Dungeon Achievements (060-069)
		public static const DUNGEON_DELVER:int					= 060;
		public static const DUNGEON_DELVER_MASTER:int			= 061;
		public static const DUNGEON_SHUT_DOWN_EVERYTHING:int	= 062;
		public static const DUNGEON_YOURE_IN_DEEP:int			= 063;
		public static const DUNGEON_SAND_WITCH_FRIEND:int		= 064;
		public static const DUNGEON_PHOENIX_FALL:int			= 065;
		public static const DUNGEON_ACCOMPLICE:int				= 066; //shadow achievement
		public static const DUNGEON_EXTREMELY_CHASTE_DELVER:int	= 067; //shadow achievement
		public static const DUNGEON_DELVER_APPRENTICE:int		= 068;
		public static const DUNGEON_END_OF_REIGN:int			= 069;

		//Fashion and Wealth Achievements (070-074)(075-079)
		public static const FASHION_WANNABE_WIZARD:int			= 070;
		public static const FASHION_COSPLAYER:int				= 071;
		public static const FASHION_DOMINATRIX:int				= 072;
		public static const FASHION_GOING_COMMANDO:int			= 073;
		public static const FASHION_BLING_BLING:int				= 074;
		public static const WEALTH_RICH:int						= 075;
		public static const WEALTH_HOARDER:int					= 076;
		public static const WEALTH_GEM_VAULT:int				= 077;
		public static const WEALTH_MILLIONAIRE:int				= 078;
		public static const WEALTH_ITEM_VAULT:int				= 079;

		//Combat Achievements (080-089)
		public static const COMBAT_WIZARD:int					= 080; //Learn all black and white spells.
		public static const COMBAT_CUM_CANNON:int				= 081; //Cum in the middle of battle.
		public static const COMBAT_PAIN:int						= 082; //50 damage
		public static const COMBAT_FRACTURED_LIMBS:int			= 083; //100 damage
		public static const COMBAT_BROKEN_BONES:int				= 084; //250 damage
		public static const COMBAT_OVERKILL:int					= 085; //500 damage (shadow achievement?)
		public static const COMBAT_SHOT_WEB:int					= 086; //How do I shot web?
		public static const COMBAT_DAMAGE_SPONGE:int			= 087;
		public static const COMBAT_BLOOD_LETTER:int				= 088;
		public static const COMBAT_PACIFIST:int					= 089;

		//Holiday Achievements (090-099)
		public static const HOLIDAY_EGG_HUNTER:int				= 090;
		public static const HOLIDAY_HELIA_BIRTHDAY:int			= 091;
		public static const HOLIDAY_THANKSGIVING_I:int			= 092;
		public static const HOLIDAY_THANKSGIVING_II:int			= 093;
		public static const HOLIDAY_HALLOWEEN_I:int				= 094;
		public static const HOLIDAY_HALLOWEEN_II:int			= 095;
		public static const HOLIDAY_CHRISTMAS_I:int				= 096;
		public static const HOLIDAY_CHRISTMAS_II:int			= 097;
		public static const HOLIDAY_CHRISTMAS_III:int			= 098;
		public static const HOLIDAY_VALENTINE:int				= 099;

		//Hunger Achievements (100-104)
		public static const REALISTIC_TASTES_LIKE_CHICKEN:int	= 100;
		public static const REALISTIC_CHAMPION_NEEDS_FOOD:int	= 101; //Champion needs food badly!
		public static const REALISTIC_GOURMAND:int				= 102;
		public static const REALISTIC_GLUTTON:int				= 103;
		public static const REALISTIC_FASTING:int				= 104;

		//Challenge Achievements (105-109)
		public static const CHALLENGE_ULTIMATE_NOOB:int			= 105; //Defeat Lethice at level 1.
		public static const CHALLENGE_ULTIMATE_MUNDANE:int		= 106; //Defeat Lethice without spells. NOT USED.
		public static const UNKNOWN_ACHIEVEMENT_107:int			= 107;
		public static const UNKNOWN_ACHIEVEMENT_108:int			= 108;
		public static const UNKNOWN_ACHIEVEMENT_109:int			= 109;

		//General Achievements (110+)
		public static const GENERAL_PORTAL_DEFENDER:int			= 110; //Defeat 25 demons and sleep 10 times.
		public static const GENERAL_BAD_ENDER:int				= 111; //Cause 3 bad ends to various NPCs.
		public static const GENERAL_GAME_OVER:int				= 112; //Get a Bad End.
		public static const GENERAL_URINE_TROUBLE:int			= 113; //Urinate once in the realm of Mareth.
		public static const GENERAL_WHATS_HAPPENING_TO_ME:int	= 114; //Transform for the first time.
		public static const GENERAL_TRANSFORMER:int				= 115; //Transform 10 times.
		public static const GENERAL_SHAPESHIFTY:int				= 116; //Transform 25 times.
		public static const GENERAL_FAPFAPFAP:int				= 117; //Masturbate for the first time.
		public static const GENERAL_FAPTASTIC:int				= 118; //Masturbate 10 times.
		public static const GENERAL_FAPSTER:int					= 119; //Masturbate 100 times.
		public static const GENERAL_HELSPAWN:int				= 120;
		public static const GENERAL_GOO_ARMOR:int				= 121;
		public static const GENERAL_URTA_TRUE_LOVER:int			= 122;
		public static const GENERAL_DRESSTACULAR:int			= 123;
		public static const GENERAL_GODSLAYER:int				= 124;
		public static const GENERAL_GOTTA_LOVE_THEM_ALL:int		= 125;
		public static const GENERAL_FOLLOW_THE_LEADER:int		= 126;
		public static const GENERAL_MEET_YOUR_MASTER:int		= 127;
		public static const GENERAL_MEET_YOUR_MASTER_TRUE:int	= 128;
		public static const GENERAL_ALL_UR_PPLZ_R_BLNG_2_ME:int	= 129;
		public static const GENERAL_SCHOLAR:int					= 130;
		public static const GENERAL_HOLEY_BEING:int				= 131;
		public static const GENERAL_TRANSGENDER:int				= 132;
		public static const GENERAL_FREELOADER:int				= 133;
		public static const GENERAL_PERKY:int					= 134;
		public static const GENERAL_SUPER_PERKY:int				= 135;
		public static const GENERAL_STATS_50:int				= 136;
		public static const GENERAL_STATS_100:int				= 137;
		public static const GENERAL_SCHIZO:int					= 138;
		public static const GENERAL_CLEAN_SLATE:int				= 139;
		public static const GENERAL_EVERYBODY_LOVES_ME:int		= 140;
		public static const GENERAL_RETURN_TO_INGNAM:int		= 141;
		public static const GENERAL_LIKE_CHUCK_NORRIS:int		= 142;
		public static const GENERAL_FAIRY_FRENZY:int			= 143;
		public static const GENERAL_TENTACLE_BEAST_SLAYER:int	= 144;
		public static const GENERAL_HOME_SWEET_HOME:int			= 145;
		public static const GENERAL_GETAWAY:int					= 146;
		public static const GENERAL_CONVERSATIONALIST:int		= 147;
		public static const GENERAL_PEOPLE_PERSON:int			= 148;
		public static const GENERAL_RESTART_THE_RACES:int		= 149;
		public static const GENERAL_OLD_TIMES:int				= 150;
		public static const GENERAL_REGULAR:int					= 151;
		public static const GENERAL_DRUNK:int					= 152;
		public static const GENERAL_SMASHED:int					= 153;
		public static const GENERAL_IM_NO_LUMBERJACK:int		= 154;
		public static const GENERAL_DEFORESTER:int				= 155;
		public static const GENERAL_HAMMER_TIME:int				= 156;
		public static const GENERAL_NAIL_SCAVENGER:int			= 157;
		public static const GENERAL_FREE_ALL_THE_SLAVES:int		= 158;
		public static const GENERAL_YIN_YANG:int				= 159;
		public static const GENERAL_MY_TENT_NOT_BETTER:int		= 160;
		public static const GENERAL_MINERVA_PURIFICATION:int	= 161; //Shadow achievement
		public static const GENERAL_FENCER:int					= 162; //Shadow achievement
		public static const GENERAL_GAME_BREAKER:int			= 163; //Might be awarded for breaking the game.
		public static const GENERAL_FUCK_WITH_PORTALS:int		= 164;
		public static const GENERAL_GETTING_WOOD:int			= 165; //Minecraft reference
		public static const GENERAL_DICK_BANISHER:int			= 166;
		public static const GENERAL_ULTRA_PERKY:int				= 167;
		public static const GENERAL_UP_TO_11:int				= 168; //This one goes to eleven.
		public static const GENERAL_YOU_BASTARD:int				= 169;
		public static const GENERAL_YABBA_DABBA_DOO:int			= 170;
		public static const GENERAL_ANTWORKS:int				= 171;
		public static const GENERAL_OFF_WITH_HER_HEAD:int		= 172; //Awarded for beheading Lethice.
		public static const GENERAL_NOOOOOOO:int				= 173; //Insert Darth Vader voice here.
		public static const GENERAL_KAIZO_TRAP:int				= 174; //Fall victim to Kaizo Trap. NOT USED.
		public static const GENERAL_SAVE_SCUMMER:int			= 175; //Save scum. NOT USED.
		public static const GENERAL_MAKE_MARETH_GREAT_AGAIN:int	= 176; //Make Mareth Great Again indeed!
	}

}