{

// Add soldier names

SoldierNamePool *american = new SoldierNamePool();

american->load("American");

_names.push_back(american);

SoldierNamePool *british = new SoldierNamePool();

british->load("British");

_names.push_back(british);

SoldierNamePool *french = new SoldierNamePool();

french->load("French");

_names.push_back(french);

SoldierNamePool *german = new SoldierNamePool();

german->load("German");

_names.push_back(german);

SoldierNamePool *japanese = new SoldierNamePool();

japanese->load("Japanese");

_names.push_back(japanese);

SoldierNamePool *russian = new SoldierNamePool();

russian->load("Russian");

_names.push_back(russian);

// Add countries

RuleCountry *usa = new RuleCountry("STR_USA");

usa->setMinFunding(600);

usa->setMaxFunding(1200);

usa->setLabelLongitude(4.53786);

usa->setLabelLatitude(-0.698132);

RuleCountry *russia = new RuleCountry("STR_RUSSIA");

russia->setMinFunding(230);

russia->setMaxFunding(460);

russia->setLabelLongitude(1.0472);

russia->setLabelLatitude(-1.0472);

RuleCountry *uk = new RuleCountry("STR_UK");

uk->setMinFunding(240);

uk->setMaxFunding(480);

uk->setLabelLongitude(6.24828);

uk->setLabelLatitude(-0.935933);

RuleCountry *france = new RuleCountry("STR_FRANCE");

france->setMinFunding(320);

france->setMaxFunding(640);

france->setLabelLongitude(0.0436332);

france->setLabelLatitude(-0.811578);

RuleCountry *germany = new RuleCountry("STR_GERMANY");

germany->setMinFunding(250);

germany->setMaxFunding(500);

germany->setLabelLongitude(0.200713);

germany->setLabelLatitude(-0.872665);

RuleCountry *italy = new RuleCountry("STR_ITALY");

italy->setMinFunding(160);

italy->setMaxFunding(320);

italy->setLabelLongitude(0.218166);

italy->setLabelLatitude(-0.765763);

RuleCountry *spain = new RuleCountry("STR_SPAIN");

spain->setMinFunding(140);

spain->setMaxFunding(280);

spain->setLabelLongitude(6.23955);

spain->setLabelLatitude(-0.743947);

RuleCountry *china = new RuleCountry("STR_CHINA");

china->setMinFunding(245);

china->setMaxFunding(490);

china->setLabelLongitude(1.74533);

china->setLabelLatitude(-0.610865);

RuleCountry *japan = new RuleCountry("STR_JAPAN");

japan->setMinFunding(400);

japan->setMaxFunding(800);

japan->setLabelLongitude(2.40855);

japan->setLabelLatitude(-0.667588);

RuleCountry *india = new RuleCountry("STR_INDIA");

india->setMinFunding(150);

india->setMaxFunding(300);

india->setLabelLongitude(1.39626);

india->setLabelLatitude(-0.418879);

RuleCountry *brazil = new RuleCountry("STR_BRAZIL");

brazil->setMinFunding(300);

brazil->setMaxFunding(600);

brazil->setLabelLongitude(5.32325);

brazil->setLabelLatitude(0.0872665);

RuleCountry *australia = new RuleCountry("STR_AUSTRALIA");

australia->setMinFunding(280);

australia->setMaxFunding(560);

australia->setLabelLongitude(2.35619);

australia->setLabelLatitude(0.436332);

RuleCountry *nigeria = new RuleCountry("STR_NIGERIA");

nigeria->setMinFunding(180);

nigeria->setMaxFunding(360);

nigeria->setLabelLongitude(0.1309);

nigeria->setLabelLatitude(-0.174533);

RuleCountry *africa = new RuleCountry("STR_SOUTH_AFRICA");

africa->setMinFunding(230);

africa->setMaxFunding(460);

africa->setLabelLongitude(0.436332);

africa->setLabelLatitude(0.523599);

RuleCountry *egypt = new RuleCountry("STR_EGYPT");

egypt->setMinFunding(230);

egypt->setMaxFunding(460);

egypt->setLabelLongitude(0.506145);

egypt->setLabelLatitude(-0.453786);

RuleCountry *canada = new RuleCountry("STR_CANADA");

canada->setMinFunding(230);

canada->setMaxFunding(460);

canada->setLabelLongitude(4.53786);

canada->setLabelLatitude(-0.959931);

_countries.insert(std::pair<std::string, RuleCountry*>("STR_USA", usa));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_RUSSIA", russia));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_UK", uk));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_FRANCE", france));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_GERMANY", germany));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_ITALY", italy));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_SPAIN", spain));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_CHINA", china));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_JAPAN", japan));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_INDIA", india));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_BRAZIL", brazil));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_AUSTRALIA", australia));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_NIGERIA", nigeria));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_SOUTH_AFRICA", africa));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_EGYPT", egypt));

_countries.insert(std::pair<std::string, RuleCountry*>("STR_CANADA", canada));

// Add regions

RuleRegion* namerica = new RuleRegion("STR_NORTH_AMERICA");

namerica->setBaseCost(800000);

namerica->addArea(3.40339, 5.32107, -1.22173, -0.962113);

namerica->addArea(4.01426, 5.32107, -0.959931, -0.52578);

namerica->addArea(4.18879, 5.23381, -0.523599, -0.176715);

namerica->getCities()->push_back(new City("STR_NEW_YORK", 4.99382, -0.711222));

namerica->getCities()->push_back(new City("STR_WASHINGTON", 4.9371, -0.676315));

namerica->getCities()->push_back(new City("STR_LOS_ANGELES", 4.21933, -0.595594));

namerica->getCities()->push_back(new City("STR_MONTREAL", 4.9611, -0.794125));

namerica->getCities()->push_back(new City("STR_HAVANA", 4.84547, -0.392699));

namerica->getCities()->push_back(new City("STR_MEXICO_CITY", 4.55313, -0.338158));

namerica->getCities()->push_back(new City("STR_CHICAGO", 4.75384, -0.730857));

namerica->getCities()->push_back(new City("STR_VANCOUVER", 4.13207, -0.861756));

namerica->getCities()->push_back(new City("STR_DALLAS", 4.59676, -0.571595));

RuleRegion* arctic = new RuleRegion("STR_ARCTIC");

arctic->setBaseCost(950000);

arctic->addArea(0, 6.281, -1.5708, -1.22391);

RuleRegion* antarctica = new RuleRegion("STR_ANTARCTICA");

antarctica->setBaseCost(900000);

antarctica->addArea(0, 6.281, 1.0472, 1.5708);

RuleRegion* samerica = new RuleRegion("STR_SOUTH_AMERICA");

samerica->setBaseCost(600000);

samerica->addArea(4.71239, 5.49561, -0.174533, -0.00218166);

samerica->addArea(4.79966, 5.7574, 0, 0.259618);

samerica->addArea(4.79966, 5.67014, 0.261799, 1.04502);

samerica->getCities()->push_back(new City("STR_BRASILIA", 5.44761, 0.274889));

samerica->getCities()->push_back(new City("STR_BOGOTA", 4.98946, -0.0785398));

samerica->getCities()->push_back(new City("STR_BUENOS_AIRES", 5.27962, 0.602139));

samerica->getCities()->push_back(new City("STR_SANTIAGO", 5.05055, 0.582504));

samerica->getCities()->push_back(new City("STR_RIO_DE_JANEIRO", 5.53051, 0.399244));

samerica->getCities()->push_back(new City("STR_LIMA", 4.93928, 0.20944));

samerica->getCities()->push_back(new City("STR_CARACAS", 5.116, -0.18326));

RuleRegion* europe = new RuleRegion("STR_EUROPE");

europe->setBaseCost(1000000);

europe->addArea(5.84685, 1.04502, -1.22173, -0.613047);

europe->getCities()->push_back(new City("STR_LONDON", 6.281, -0.898845));

europe->getCities()->push_back(new City("STR_PARIS", 0.0414516, -0.850848));

europe->getCities()->push_back(new City("STR_BERLIN", 0.233438, -0.916298));

europe->getCities()->push_back(new City("STR_MOSCOW", 0.65668, -0.973021));

europe->getCities()->push_back(new City("STR_ROME", 0.218166, -0.730857));

europe->getCities()->push_back(new City("STR_MADRID", 6.21774, -0.704677));

europe->getCities()->push_back(new City("STR_BUDAPEST", 0.333794, -0.829031));

RuleRegion* nafrica = new RuleRegion("STR_NORTH_AFRICA");

nafrica->setBaseCost(650000);

nafrica->addArea(5.84685, 0.69595, -0.610865, -0.263981);

nafrica->addArea(5.84685, 0.957749, -0.261799, -0.00218166);

nafrica->getCities()->push_back(new City("STR_LAGOS", 0.0545415, -0.113446));

nafrica->getCities()->push_back(new City("STR_CAIRO", 0.545415, -0.523599));

nafrica->getCities()->push_back(new City("STR_CASABLANCA", 6.1501, -0.584685));

RuleRegion* safrica = new RuleRegion("STR_SOUTHERN_AFRICA");

safrica->setBaseCost(550000);

safrica->addArea(0.0872665, 0.957749, 0, 0.69595);

safrica->getCities()->push_back(new City("STR_PRETORIA", 0.490874, 0.458149));

safrica->getCities()->push_back(new City("STR_NAIROBI", 0.641409, 0.0218166));

safrica->getCities()->push_back(new City("STR_CAPE_TOWN", 0.322886, 0.593412));

safrica->getCities()->push_back(new City("STR_KINSHASA", 0.268344, 0.0763582));

RuleRegion* casia = new RuleRegion("STR_CENTRAL_ASIA");

casia->setBaseCost(500000);

casia->addArea(0.698132, 1.21955, -0.610865, -0.263981);

casia->addArea(1.0472, 1.56861, -0.872665, -0.613047);

casia->addArea(1.22173, 1.56861, -0.610865, -0.0894481);

casia->getCities()->push_back(new City("STR_ANKARA", 0.571595, -0.69595));

casia->getCities()->push_back(new City("STR_DELHI", 1.34827, -0.4996));

casia->getCities()->push_back(new City("STR_KARACHI", 1.16937, -0.434151));

casia->getCities()->push_back(new City("STR_BAGHDAD", 0.776672, -0.580322));

casia->getCities()->push_back(new City("STR_TEHRAN", 0.898845, -0.621774));

casia->getCities()->push_back(new City("STR_BOMBAY", 1.27627, -0.329431));

casia->getCities()->push_back(new City("STR_CALCUTTA", 1.54243, -0.394881));

RuleRegion* seasia = new RuleRegion("STR_SOUTH_EAST_ASIA");

seasia->setBaseCost(750000);

seasia->addArea(1.5708, 1.83041, -0.872665, 0.172351);

seasia->addArea(1.8326, 2.61581, -0.872665, -0.0894481);

seasia->getCities()->push_back(new City("STR_TOKYO", 2.4391, -0.621774));

seasia->getCities()->push_back(new City("STR_BEIJING", 2.03113, -0.69595));

seasia->getCities()->push_back(new City("STR_BANGKOK", 1.75624, -0.237801));

seasia->getCities()->push_back(new City("STR_MANILA", 2.11185, -0.255254));

seasia->getCities()->push_back(new City("STR_SEOUL", 2.21657, -0.654498));

seasia->getCities()->push_back(new City("STR_SINGAPORE", 1.81296, -0.0239983));

seasia->getCities()->push_back(new City("STR_JAKARTA", 1.86314, 0.109083));

seasia->getCities()->push_back(new City("STR_SHANGHAI", 2.12058, -0.545415));

seasia->getCities()->push_back(new City("STR_HONG_KONG", 1.99186, -0.388336));

RuleRegion* siberia = new RuleRegion("STR_SIBERIA");

siberia->setBaseCost(800000);

siberia->addArea(1.0472, 3.13941, -1.22173, -0.874846);

siberia->getCities()->push_back(new City("STR_NOVOSIBIRSK", 1.44426, -0.959931));

RuleRegion* australasia = new RuleRegion("STR_AUSTRALASIA");

australasia->setBaseCost(750000);

//australasia->addArea(1.8326, 3.13941, -0.0872665, 0.870483);

australasia->addArea(1.8326, 3.13941, -0.0872665, 1.04502);

australasia->getCities()->push_back(new City("STR_CANBERRA", 2.60272, 0.61741));

australasia->getCities()->push_back(new City("STR_WELLINGTON", 3.05651, 0.719948));

australasia->getCities()->push_back(new City("STR_MELBOURNE", 2.53073, 0.661043));

australasia->getCities()->push_back(new City("STR_PERTH", 2.02022, 0.558505));

RuleRegion* pacific = new RuleRegion("STR_PACIFIC");

pacific->setBaseCost(600000);

pacific->addArea(3.14159, 3.40121, -1.22173, -0.962113);

pacific->addArea(3.14159, 4.01208, -0.959931, -0.52578);

pacific->addArea(3.14159, 4.18661, -0.523599, -0.176715);

pacific->addArea(3.14159, 4.71021, -0.174533, -0.00218166);

pacific->addArea(3.14159, 4.79747, 0, 1.04502);

pacific->addArea(2.61799, 3.13941, -0.872665, -0.0894481);

RuleRegion* natlantic = new RuleRegion("STR_NORTH_ATLANTIC");

natlantic->setBaseCost(500000);

natlantic->addArea(5.32325, 5.84467, -1.22173, -0.52578);

natlantic->addArea(5.23599, 5.84467, -0.523599, -0.176715);

natlantic->addArea(5.49779, 5.84467, -0.174533, -0.00218166);

RuleRegion* satlantic = new RuleRegion("STR_SOUTH_ATLANTIC");

satlantic->setBaseCost(500000);

satlantic->addArea(5.75959, 0.0850848, 0, 0.259618);

satlantic->addArea(5.67232, 0.0850848, 0.261799, 1.04502);

satlantic->addArea(0.0872665, 0.959931, 0.698132, 1.04502);

RuleRegion* indian = new RuleRegion("STR_INDIAN_OCEAN");

indian->setBaseCost(500000);

indian->addArea(0.959931, 1.21955, -0.261799, 0.172351);

indian->addArea(1.22173, 1.56861, -0.0872665, 0.172351);

indian->addArea(0.959931, 1.83041, 0.174533, 1.04502);

_regions.insert(std::pair<std::string, RuleRegion*>("STR_NORTH_AMERICA", namerica));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_ARCTIC", arctic));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_ANTARCTICA", antarctica));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_SOUTH_AMERICA", samerica));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_EUROPE", europe));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_NORTH_AFRICA", nafrica));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_SOUTHERN_AFRICA", safrica));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_CENTRAL_ASIA", casia));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_SOUTH_EAST_ASIA", seasia));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_SIBERIA", siberia));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_AUSTRALASIA", australasia));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_PACIFIC", pacific));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_NORTH_ATLANTIC", natlantic));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_SOUTH_ATLANTIC", satlantic));

_regions.insert(std::pair<std::string, RuleRegion*>("STR_INDIAN_OCEAN", indian));

// Add base facilities

RuleBaseFacility *lift = new RuleBaseFacility("STR_ACCESS_LIFT");

lift->setSpriteShape(2);

lift->setSpriteFacility(17);

lift->setBuildCost(300000);

lift->setBuildTime(1);

lift->setMonthlyCost(4000);

lift->setLift(true);

RuleBaseFacility *quarters = new RuleBaseFacility("STR_LIVING_QUARTERS");

quarters->setSpriteShape(1);

quarters->setSpriteFacility(18);

quarters->setBuildCost(400000);

quarters->setBuildTime(16);

quarters->setMonthlyCost(10000);

quarters->setPersonnel(50);

RuleBaseFacility *lab = new RuleBaseFacility("STR_LABORATORY");

lab->setSpriteShape(1);

lab->setSpriteFacility(19);

lab->setBuildCost(750000);

lab->setBuildTime(26);

lab->setMonthlyCost(30000);

lab->setLaboratories(50);

RuleBaseFacility *workshop = new RuleBaseFacility("STR_WORKSHOP");

workshop->setSpriteShape(1);

workshop->setSpriteFacility(20);

workshop->setBuildCost(800000);

workshop->setBuildTime(32);

workshop->setMonthlyCost(35000);

workshop->setWorkshops(50);

RuleBaseFacility *stores = new RuleBaseFacility("STR_GENERAL_STORES");

stores->setSpriteShape(1);

stores->setSpriteFacility(24);

stores->setBuildCost(150000);

stores->setBuildTime(10);

stores->setMonthlyCost(5000);

stores->setStorage(50);

RuleBaseFacility *aliens = new RuleBaseFacility("STR_ALIEN_CONTAINMENT");

aliens->setSpriteShape(1);

aliens->setSpriteFacility(25);

aliens->setBuildCost(400000);

aliens->setBuildTime(18);

aliens->setMonthlyCost(15000);

aliens->setAliens(10);

RuleBaseFacility *hangar = new RuleBaseFacility("STR_HANGAR");

hangar->setSpriteShape(9);

hangar->setSpriteFacility(9);

hangar->setSize(2);

hangar->setBuildCost(200000);

hangar->setBuildTime(25);

hangar->setMonthlyCost(25000);

hangar->setCrafts(1);

RuleBaseFacility *sRadar = new RuleBaseFacility("STR_SMALL_RADAR_SYSTEM");

sRadar->setSpriteShape(2);

sRadar->setSpriteFacility(21);

sRadar->setBuildCost(500000);

sRadar->setBuildTime(12);

sRadar->setMonthlyCost(10000);

sRadar->setRadarRange(1500);

sRadar->setRadarChance(10);

RuleBaseFacility *lRadar = new RuleBaseFacility("STR_LARGE_RADAR_SYSTEM");

lRadar->setSpriteShape(1);

lRadar->setSpriteFacility(22);

lRadar->setBuildCost(800000);

lRadar->setBuildTime(25);

lRadar->setMonthlyCost(15000);

lRadar->setRadarRange(2250);

lRadar->setRadarChance(20);

RuleBaseFacility *missile = new RuleBaseFacility("STR_MISSILE_DEFENSES");

missile->setSpriteShape(2);

missile->setSpriteFacility(23);

missile->setBuildCost(200000);

missile->setBuildTime(16);

missile->setMonthlyCost(5000);

missile->setDefenceValue(500);

missile->setHitRatio(50);

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_ACCESS_LIFT", lift));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_LIVING_QUARTERS", quarters));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_LABORATORY", lab));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_WORKSHOP", workshop));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_GENERAL_STORES", stores));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_ALIEN_CONTAINMENT", aliens));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_HANGAR", hangar));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_SMALL_RADAR_SYSTEM", sRadar));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_LARGE_RADAR_SYSTEM", lRadar));

_facilities.insert(std::pair<std::string, RuleBaseFacility*>("STR_MISSILE_DEFENSES", missile));

// Add mapdatafiles

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("AVENGER",new MapDataSet("AVENGER",59)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("BARN",new MapDataSet("BARN",29)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("BLANKS",new MapDataSet("BLANKS",2)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("BRAIN",new MapDataSet("BRAIN",4)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("CULTIVAT",new MapDataSet("CULTIVAT",37)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("DESERT",new MapDataSet("DESERT",66)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("FOREST",new MapDataSet("FOREST",83)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("FRNITURE",new MapDataSet("FRNITURE",26)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("JUNGLE",new MapDataSet("JUNGLE",82)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("LIGHTNIN",new MapDataSet("LIGHTNIN",42)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("MARS",new MapDataSet("MARS",36)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("MOUNT",new MapDataSet("MOUNT",78)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("PLANE",new MapDataSet("PLANE",65)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("POLAR",new MapDataSet("POLAR",81)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("ROADS",new MapDataSet("ROADS",23)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("UFO1",new MapDataSet("UFO1",20)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("URBAN",new MapDataSet("URBAN",112)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("URBITS",new MapDataSet("URBITS",25)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_BASE",new MapDataSet("U_BASE",67)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_BITS",new MapDataSet("U_BITS",8)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_DISEC2",new MapDataSet("U_DISEC2",17)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_EXT02",new MapDataSet("U_EXT02",34)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_OPER2",new MapDataSet("U_OPER2",15)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_PODS",new MapDataSet("U_PODS",11)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("U_WALL02",new MapDataSet("U_WALL02",47)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("XBASE1",new MapDataSet("XBASE1",97)));

_mapDataFiles.insert(std::pair<std::string, MapDataSet*>("XBASE2",new MapDataSet("XBASE2",62)));

// Add crafts

RuleCraft* skyranger = new RuleCraft("STR_SKYRANGER");

skyranger->setSprite(0);

skyranger->setMaxSpeed(760);

skyranger->setAcceleration(2);

skyranger->setMaxFuel(1500);

skyranger->setWeapons(0);

skyranger->setMaxDamage(150);

skyranger->setSoldiers(14);

skyranger->setCost(500000);

skyranger->setHWPs(3);

skyranger->setRefuelRate(50);

skyranger->setTransferTime(72);

RuleTerrain *ruleTerrain = new RuleTerrain("PLANE");

skyranger->setBattlescapeTerrainData(ruleTerrain);

ruleTerrain->getMapDataSets()->push_back(getMapDataSet("BLANKS"));

ruleTerrain->getMapDataSets()->push_back(getMapDataSet("PLANE"));

ruleTerrain->getMapBlocks()->push_back(new MapBlock(ruleTerrain,"PLANE",10,20,true));

RuleCraft* lightning = new RuleCraft("STR_LIGHTNING");

lightning->setSprite(1);

lightning->setMaxSpeed(3100);

lightning->setAcceleration(9);

lightning->setMaxFuel(30);

lightning->setWeapons(1);

lightning->setMaxDamage(800);

lightning->setSoldiers(12);

lightning->setHWPs(0);

lightning->setRefuelRate(5);

RuleCraft* avenger = new RuleCraft("STR_AVENGER");

avenger->setSprite(2);

avenger->setMaxSpeed(5400);

avenger->setAcceleration(10);

avenger->setMaxFuel(60);

avenger->setWeapons(2);

avenger->setMaxDamage(1200);

avenger->setSoldiers(26);

avenger->setHWPs(4);

avenger->setRefuelRate(5);

RuleCraft* interceptor = new RuleCraft("STR_INTERCEPTOR");

interceptor->setSprite(3);

interceptor->setMaxSpeed(2100);

interceptor->setAcceleration(3);

interceptor->setMaxFuel(1000);

interceptor->setWeapons(2);

interceptor->setMaxDamage(100);

interceptor->setSoldiers(0);

interceptor->setCost(600000);

interceptor->setHWPs(0);

interceptor->setRefuelRate(50);

interceptor->setTransferTime(96);

RuleCraft* firestorm = new RuleCraft("STR_FIRESTORM");

firestorm->setSprite(4);

firestorm->setMaxSpeed(4200);

firestorm->setAcceleration(9);

firestorm->setMaxFuel(20);

firestorm->setWeapons(2);

firestorm->setMaxDamage(50);

firestorm->setSoldiers(0);

firestorm->setHWPs(0);

firestorm->setRefuelRate(5);

_crafts.insert(std::pair<std::string, RuleCraft*>("STR_SKYRANGER", skyranger));

_crafts.insert(std::pair<std::string, RuleCraft*>("STR_LIGHTNING", lightning));

_crafts.insert(std::pair<std::string, RuleCraft*>("STR_AVENGER", avenger));

_crafts.insert(std::pair<std::string, RuleCraft*>("STR_INTERCEPTOR", interceptor));

_crafts.insert(std::pair<std::string, RuleCraft*>("STR_FIRESTORM", firestorm));

// Add craft weapons

RuleCraftWeapon *stingray = new RuleCraftWeapon("STR_STINGRAY");

stingray->setSprite(0);

stingray->setSound(8);

stingray->setDamage(70);

stingray->setRange(30);

stingray->setAccuracy(70);

stingray->setCautiousReload(32);

stingray->setStandardReload(24);

stingray->setAggressiveReload(16);

stingray->setAmmoMax(6);

stingray->setLauncherItem("STR_STINGRAY_LAUNCHER");

stingray->setClipItem("STR_STINGRAY_MISSILES");

RuleCraftWeapon *avalanche = new RuleCraftWeapon("STR_AVALANCHE");

avalanche->setSprite(1);

avalanche->setSound(8);

avalanche->setDamage(100);

avalanche->setRange(60);

avalanche->setAccuracy(80);

avalanche->setCautiousReload(48);

avalanche->setStandardReload(36);

avalanche->setAggressiveReload(24);

avalanche->setAmmoMax(3);

avalanche->setLauncherItem("STR_AVALANCHE_LAUNCHER");

avalanche->setClipItem("STR_AVALANCHE_MISSILES");

RuleCraftWeapon *cannon = new RuleCraftWeapon("STR_CANNON_UC");

cannon->setSprite(2);

cannon->setSound(4);

cannon->setDamage(10);

cannon->setRange(10);

cannon->setAccuracy(25);

cannon->setCautiousReload(2);

cannon->setStandardReload(2);

cannon->setAggressiveReload(2);

cannon->setAmmoMax(200);

cannon->setRearmRate(50);

cannon->setLauncherItem("STR_CANNON");

cannon->setClipItem("STR_CANNON_ROUNDS_X50");

RuleCraftWeapon *laser = new RuleCraftWeapon("STR_LASER_CANNON_UC");

laser->setSprite(4);

laser->setSound(5);

laser->setDamage(70);

laser->setRange(21);

laser->setAccuracy(35);

laser->setCautiousReload(12);

laser->setStandardReload(12);

laser->setAggressiveReload(12);

laser->setAmmoMax(99);

laser->setLauncherItem("STR_LASER_CANNON");

RuleCraftWeapon *plasma = new RuleCraftWeapon("STR_PLASMA_BEAM_UC");

plasma->setSprite(5);

plasma->setSound(9);

plasma->setDamage(140);

plasma->setRange(52);

plasma->setAccuracy(50);

plasma->setCautiousReload(12);

plasma->setStandardReload(12);

plasma->setAggressiveReload(12);

plasma->setAmmoMax(100);

plasma->setLauncherItem("STR_PLASMA_BEAM");

RuleCraftWeapon *fusion = new RuleCraftWeapon("STR_FUSION_BALL_UC");

fusion->setSprite(3);

fusion->setSound(7);

fusion->setDamage(230);

fusion->setRange(65);

fusion->setAccuracy(100);

fusion->setCautiousReload(32);

fusion->setStandardReload(24);

fusion->setAggressiveReload(16);

fusion->setAmmoMax(2);

fusion->setLauncherItem("STR_FUSION_BALL_LAUNCHER");

fusion->setClipItem("STR_FUSION_BALL");

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_STINGRAY", stingray));

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_AVALANCHE", avalanche));

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_CANNON_UC", cannon));

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_FUSION_BALL_UC", fusion));

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_LASER_CANNON_UC", laser));

_craftWeapons.insert(std::pair<std::string, RuleCraftWeapon*>("STR_PLASMA_BEAM_UC", plasma));

// Add items

RuleItem *slauncher = new RuleItem("STR_STINGRAY_LAUNCHER");

slauncher->setSize(0.8f);

slauncher->setCost(16000);

slauncher->setTransferTime(48);

RuleItem *alauncher = new RuleItem("STR_AVALANCHE_LAUNCHER");

alauncher->setSize(1.0f);

alauncher->setCost(17000);

alauncher->setTransferTime(48);

RuleItem *icannon = new RuleItem("STR_CANNON");

icannon->setSize(1.5f);

icannon->setCost(30000);

icannon->setTransferTime(48);

RuleItem *smissile = new RuleItem("STR_STINGRAY_MISSILES");

smissile->setSize(0.4f);

smissile->setCost(3000);

smissile->setTransferTime(48);

RuleItem *amissile = new RuleItem("STR_AVALANCHE_MISSILES");

amissile->setSize(1.5f);

amissile->setCost(9000);

amissile->setTransferTime(48);

RuleItem *crounds = new RuleItem("STR_CANNON_ROUNDS_X50");

crounds->setSize(0.0f);

crounds->setCost(1240);

crounds->setTransferTime(96);

RuleItem *pistol = new RuleItem("STR_PISTOL");

pistol->setSize(0.1f);

pistol->setCost(800);

pistol->setBigSprite(3);

pistol->setHandSprite(96);

pistol->setBulletSprite(1);

pistol->setFireSound(4);

pistol->setAccuracySnap(60);

pistol->setTUSnap(18);

pistol->setTUAuto(18);

pistol->setAccuracyAimed(78);

pistol->setTUAimed(30);

pistol->getCompatibleAmmo()->push_back("STR_PISTOL_CLIP");

pistol->setBattleType(BT_FIREARM);

pistol->setInventoryWidth(1);

pistol->setInventoryHeight(2);

pistol->setWeight(5);

RuleItem *pclip = new RuleItem("STR_PISTOL_CLIP");

pclip->setSize(0.1f);

pclip->setCost(70);

pclip->setBigSprite(4);

pclip->setPower(26);

pclip->setDamageType(DT_AP);

pclip->setBattleType(BT_AMMO);

pclip->setHitAnimation(26);

pclip->setHitSound(22);

pclip->setClipSize(12);

pclip->setWeight(3);

RuleItem *rifle = new RuleItem("STR_RIFLE");

rifle->setSize(0.2f);

rifle->setCost(3000);

rifle->setBigSprite(1);

rifle->setHandSprite(0);

rifle->setTwoHanded(true);

rifle->setBulletSprite(2);

rifle->setFireSound(4);

rifle->setAccuracyAuto(35);

rifle->setTUAuto(35);

rifle->setAccuracySnap(60);

rifle->setTUSnap(25);

rifle->setAccuracyAimed(110);

rifle->setTUAimed(80);

rifle->getCompatibleAmmo()->push_back("STR_RIFLE_CLIP");

rifle->setBattleType(BT_FIREARM);

rifle->setInventoryWidth(1);

rifle->setInventoryHeight(3);

rifle->setWeight(8);

RuleItem *rclip = new RuleItem("STR_RIFLE_CLIP");

rclip->setSize(0.1f);

rclip->setCost(200);

rclip->setBigSprite(2);

rclip->setPower(30);

rclip->setDamageType(DT_AP);

rclip->setBattleType(BT_AMMO);

rclip->setHitAnimation(26);

rclip->setHitSound(22);

rclip->setClipSize(20);

rclip->setWeight(3);

RuleItem *hcannon = new RuleItem("STR_HEAVY_CANNON");

hcannon->setSize(0.3f);

hcannon->setCost(6400);

hcannon->setBigSprite(11);

hcannon->setHandSprite(24);

hcannon->setTwoHanded(true);

hcannon->setBulletSprite(4);

hcannon->setFireSound(2);

hcannon->setAccuracySnap(60);

hcannon->setTUSnap(33);

hcannon->setTUAuto(33);

hcannon->setAccuracyAimed(90);

hcannon->setTUAimed(80);

hcannon->getCompatibleAmmo()->push_back("STR_HC_AP_AMMO");

hcannon->getCompatibleAmmo()->push_back("STR_HC_HE_AMMO");

hcannon->getCompatibleAmmo()->push_back("STR_HC_I_AMMO");

hcannon->setBattleType(BT_FIREARM);

hcannon->setInventoryWidth(2);

hcannon->setInventoryHeight(3);

hcannon->setWeight(18);

RuleItem *hcap = new RuleItem("STR_HC_AP_AMMO");

hcap->setSize(0.1f);

hcap->setCost(300);

hcap->setBigSprite(12);

hcap->setPower(56);

hcap->setDamageType(DT_AP);

hcap->setBattleType(BT_AMMO);

hcap->setHitAnimation(26);

hcap->setHitSound(13);

hcap->setInventoryWidth(2);

hcap->setInventoryHeight(1);

hcap->setClipSize(6);

hcap->setWeight(6);

RuleItem *hche = new RuleItem("STR_HC_HE_AMMO");

hche->setSize(0.1f);

hche->setCost(500);

hche->setBigSprite(13);

hche->setPower(52);

hche->setDamageType(DT_HE);

hche->setBattleType(BT_AMMO);

hche->setHitAnimation(0);

hche->setHitSound(0);

hche->setInventoryWidth(2);

hche->setInventoryHeight(1);

hche->setClipSize(6);

hche->setWeight(6);

RuleItem *hci = new RuleItem("STR_HC_I_AMMO");

hci->setSize(0.1f);

hci->setCost(400);

hci->setBigSprite(14);

hci->setPower(60);

hci->setDamageType(DT_IN);

hci->setBattleType(BT_AMMO);

hci->setHitAnimation(0);

hci->setHitSound(0);

hci->setInventoryWidth(2);

hci->setInventoryHeight(1);

hci->setClipSize(6);

hci->setWeight(6);

RuleItem *acannon = new RuleItem("STR_AUTO_CANNON");

acannon->setSize(0.3f);

acannon->setCost(13500);

acannon->setBigSprite(7);

acannon->setHandSprite(32);

acannon->setTwoHanded(true);

acannon->setBulletSprite(3);

acannon->setFireSound(2);

acannon->setAccuracyAuto(32);

acannon->setTUAuto(40);

acannon->setAccuracySnap(56);

acannon->setTUSnap(33);

acannon->setAccuracyAimed(82);

acannon->setTUAimed(80);

acannon->getCompatibleAmmo()->push_back("STR_AC_AP_AMMO");

acannon->getCompatibleAmmo()->push_back("STR_AC_HE_AMMO");

acannon->getCompatibleAmmo()->push_back("STR_AC_I_AMMO");

acannon->setBattleType(BT_FIREARM);

acannon->setInventoryWidth(2);

acannon->setInventoryHeight(3);

acannon->setWeight(19);

RuleItem *acap = new RuleItem("STR_AC_AP_AMMO");

acap->setSize(0.1f);

acap->setCost(500);

acap->setBigSprite(8);

acap->setPower(42);

acap->setDamageType(DT_AP);

acap->setBattleType(BT_AMMO);

acap->setHitSound(13);

acap->setHitAnimation(26);

acap->setInventoryWidth(2);

acap->setInventoryHeight(1);

acap->setClipSize(14);

acap->setWeight(5);

RuleItem *ache = new RuleItem("STR_AC_HE_AMMO");

ache->setSize(0.1f);

ache->setCost(700);

ache->setBigSprite(9);

ache->setPower(44);

ache->setDamageType(DT_HE);

ache->setBattleType(BT_AMMO);

ache->setHitSound(0);

ache->setHitAnimation(0);

ache->setInventoryWidth(2);

ache->setInventoryHeight(1);

ache->setClipSize(14);

ache->setWeight(5);

RuleItem *aci = new RuleItem("STR_AC_I_AMMO");

aci->setSize(0.1f);

aci->setCost(650);

aci->setBigSprite(10);

aci->setPower(42);

aci->setDamageType(DT_IN);

aci->setBattleType(BT_AMMO);

aci->setHitSound(0);

aci->setHitAnimation(0);

aci->setInventoryWidth(2);

aci->setInventoryHeight(1);

aci->setClipSize(14);

aci->setWeight(5);

RuleItem *rlauncher = new RuleItem("STR_ROCKET_LAUNCHER");

rlauncher->setSize(0.4f);

rlauncher->setCost(4000);

rlauncher->setBigSprite(15);

rlauncher->setHandSprite(9);

rlauncher->setTwoHanded(true);

rlauncher->setBulletSprite(0);

rlauncher->setFireSound(52);

rlauncher->setAccuracySnap(55);

rlauncher->setTUSnap(45);

rlauncher->setTUAuto(45);

rlauncher->setAccuracyAimed(115);

rlauncher->setTUAimed(75);

rlauncher->getCompatibleAmmo()->push_back("STR_SMALL_ROCKET");

rlauncher->getCompatibleAmmo()->push_back("STR_LARGE_ROCKET");

rlauncher->getCompatibleAmmo()->push_back("STR_INCENDIARY_ROCKET");

rlauncher->setBattleType(BT_FIREARM);

rlauncher->setInventoryWidth(2);

rlauncher->setInventoryHeight(3);

rlauncher->setWeight(10);

RuleItem *srocket = new RuleItem("STR_SMALL_ROCKET");

srocket->setSize(0.2f);

srocket->setCost(600);

srocket->setBigSprite(16);

srocket->setPower(75);

srocket->setDamageType(DT_HE);

srocket->setBattleType(BT_AMMO);

srocket->setHitSound(0);

srocket->setHitAnimation(0);

srocket->setInventoryWidth(1);

srocket->setInventoryHeight(3);

srocket->setClipSize(1);

srocket->setWeight(6);

RuleItem *lrocket = new RuleItem("STR_LARGE_ROCKET");

lrocket->setSize(0.2f);

lrocket->setCost(900);

lrocket->setBigSprite(17);

lrocket->setPower(100);

lrocket->setDamageType(DT_HE);

lrocket->setBattleType(BT_AMMO);

lrocket->setHitSound(0);

lrocket->setHitAnimation(0);

lrocket->setInventoryWidth(1);

lrocket->setInventoryHeight(3);

lrocket->setClipSize(1);

lrocket->setWeight(8);

RuleItem *irocket = new RuleItem("STR_INCENDIARY_ROCKET");

irocket->setSize(0.2f);

irocket->setCost(1200);

irocket->setBigSprite(18);

irocket->setPower(90);

irocket->setDamageType(DT_IN);

irocket->setBattleType(BT_AMMO);

irocket->setHitSound(0);

irocket->setHitAnimation(0);

irocket->setInventoryWidth(1);

irocket->setInventoryHeight(3);

irocket->setClipSize(1);

irocket->setWeight(8);

RuleItem *grenade = new RuleItem("STR_GRENADE");

grenade->setSize(0.1f);

grenade->setCost(300);

grenade->setBigSprite(19);

grenade->setPower(50);

grenade->setDamageType(DT_HE);

grenade->setBattleType(BT_GRENADE);

grenade->setWeight(3);

RuleItem *sgrenade = new RuleItem("STR_SMOKE_GRENADE");

sgrenade->setSize(0.1f);

sgrenade->setCost(150);

sgrenade->setBigSprite(20);

sgrenade->setPower(60);

sgrenade->setDamageType(DT_SMOKE);

sgrenade->setBattleType(BT_GRENADE);

sgrenade->setWeight(3);

RuleItem *corpse = new RuleItem("STR_CORPSE");

corpse->setBigSprite(45);

corpse->setFloorSprite(39);

corpse->setInventoryWidth(2);

corpse->setInventoryHeight(3);

corpse->setWeight(22);

RuleItem *scorpse = new RuleItem("STR_SECTOID_CORPSE");

scorpse->setBigSprite(46);

scorpse->setFloorSprite(42);

scorpse->setInventoryWidth(2);

scorpse->setInventoryHeight(3);

scorpse->setWeight(30);

RuleItem *ppistol = new RuleItem("STR_PLASMA_PISTOL");

ppistol->setSize(0.1f);

ppistol->setCost(800);

ppistol->setBigSprite(32);

ppistol->setHandSprite(104);

ppistol->setFloorSprite(31);

ppistol->setBulletSprite(8);

ppistol->setFireSound(18);

ppistol->setAccuracyAuto(50);

ppistol->setTUAuto(30);

ppistol->setAccuracySnap(65);

ppistol->setTUSnap(30);

ppistol->setAccuracyAimed(85);

ppistol->setTUAimed(60);

ppistol->getCompatibleAmmo()->push_back("STR_PLASMA_PISTOL_CLIP");

ppistol->setBattleType(BT_FIREARM);

ppistol->setInventoryWidth(1);

ppistol->setInventoryHeight(2);

ppistol->setWeight(3);

RuleItem *ppclip = new RuleItem("STR_PLASMA_PISTOL_CLIP");

ppclip->setSize(0.1f);

ppclip->setCost(70);

ppclip->setBigSprite(34);

ppclip->setPower(52);

ppclip->setDamageType(DT_PLASMA);

ppclip->setBattleType(BT_AMMO);

ppclip->setHitAnimation(46);

ppclip->setHitSound(19);

ppclip->setClipSize(26);

ppclip->setWeight(3);

_items.insert(std::pair<std::string, RuleItem*>("STR_STINGRAY_LAUNCHER", slauncher));

_items.insert(std::pair<std::string, RuleItem*>("STR_AVALANCHE_LAUNCHER", alauncher));

_items.insert(std::pair<std::string, RuleItem*>("STR_CANNON", icannon));

_items.insert(std::pair<std::string, RuleItem*>("STR_STINGRAY_MISSILES", smissile));

_items.insert(std::pair<std::string, RuleItem*>("STR_AVALANCHE_MISSILES", amissile));

_items.insert(std::pair<std::string, RuleItem*>("STR_CANNON_ROUNDS_X50", crounds));

_items.insert(std::pair<std::string, RuleItem*>("STR_PISTOL", pistol));

_items.insert(std::pair<std::string, RuleItem*>("STR_PISTOL_CLIP", pclip));

_items.insert(std::pair<std::string, RuleItem*>("STR_RIFLE", rifle));

_items.insert(std::pair<std::string, RuleItem*>("STR_RIFLE_CLIP", rclip));

_items.insert(std::pair<std::string, RuleItem*>("STR_HEAVY_CANNON", hcannon));

_items.insert(std::pair<std::string, RuleItem*>("STR_HC_AP_AMMO", hcap));

_items.insert(std::pair<std::string, RuleItem*>("STR_HC_HE_AMMO", hche));

_items.insert(std::pair<std::string, RuleItem*>("STR_HC_I_AMMO", hci));

_items.insert(std::pair<std::string, RuleItem*>("STR_AUTO_CANNON", acannon));

_items.insert(std::pair<std::string, RuleItem*>("STR_AC_AP_AMMO", acap));

_items.insert(std::pair<std::string, RuleItem*>("STR_AC_HE_AMMO", ache));

_items.insert(std::pair<std::string, RuleItem*>("STR_AC_I_AMMO", aci));

_items.insert(std::pair<std::string, RuleItem*>("STR_ROCKET_LAUNCHER", rlauncher));

_items.insert(std::pair<std::string, RuleItem*>("STR_SMALL_ROCKET", srocket));