/**
* Principal function. It creates Nodes and Edges to put in the Graph,
* from the given BBHG
* @param bhg source BBHG
*/
void BBHGDrawer::make() {
if(_made) {
return;
}
ASSERT(_bhg);
ASSERT(_graph);
// Construct the Graph
HashTable<void*, display::Node*> map;
for(BBHG::Iterator bb(_bhg); bb; bb++) {
display::Node *node = _graph->newNode();
map.put(*bb, node);
onNode(*bb, node);
}
for(BBHG::Iterator bb(_bhg); bb; bb++) {
display::Node *node = map.get(*bb);
for(BBHG::OutIterator succ(bb); succ; succ++) {
BBHGEdge* edge = succ;
display::Edge *display_edge;
display_edge = _graph->newEdge(node,map.get(edge->target()));
onEdge(edge, display_edge);
}
}
onEnd(_graph);
_made = true;
}
void HashTableTest::testInsert()
{
std::string s1("str1");
std::string s2("str2");
HashTable<std::string, int> hashTable;
assert (!hashTable.exists(s1));
hashTable.insert(s1, 13);
assert (hashTable.exists(s1));
assert (hashTable.get(s1) == 13);
int retVal = 0;
assert (hashTable.get(s1, retVal));
assert (retVal == 13);
try
{
hashTable.insert(s1, 22);
failmsg ("duplicate insert must fail");
}
catch (Exception&){}
try
{
hashTable.get(s2);
failmsg ("getting a non inserted item must fail");
}
catch (Exception&){}
assert (!hashTable.exists(s2));
hashTable.insert(s2, 13);
assert (hashTable.exists(s2));
}
int main(int argc, const char * argv[]) {
HashTable * ht = new HashTable();
ht->put("one", "1");
ht->put("two", "2");
ht->put("three", "3");
ht->put("four", "4");
ht->put("five", "5");
ht->put("six", "6");
ht->put("seven", "7");
string value = ht->get("three");
if (!value.empty())
cout << value << endl;
value = ht->get("two");
if (!value.empty())
cout << value << endl;
value = ht->get("one");
if (!value.empty())
cout << value << endl;
value = ht->get("zero");
if (!value.empty())
cout << value << endl;
value = ht->get("seven");
if (!value.empty())
cout << value << endl;
delete ht;
return 0;
}
void HashTableTest::testUpdate()
{
// add code for second test here
std::string s1("str1");
std::string s2("str2");
HashTable<std::string, int> hashTable;
hashTable.insert(s1, 13);
hashTable.update(s1, 14);
assert (hashTable.exists(s1));
assert (hashTable.get(s1) == 14);
int retVal = 0;
assert (hashTable.get(s1, retVal));
assert (retVal == 14);
// updating a non existing item must work too
hashTable.update(s2, 15);
assert (hashTable.get(s2) == 15);
}
void testHashTable()
{
HashTable<int> table;
for (char i = 48; i < 58; i++) { //ascii 0
string key(string("test ") + string(&i));
table.set(key, i);
int val = table.get(key);
cout << key << ": " << val << endl;
}
}
int main() {
HashTable h;
h.put(10,10);
h.put(130,130);
h.put(8,8);
h.put(128,128);
h.put(40,40);
h.put(1,1);
h.put(0,0);
h.put(10,20);
cout << h.get(10) << endl;
return 0;
}
int main(){
HashTable<int, string> t;
for (int k=0; k < 100; k++){
int l = k*42;
for (int i=l; i < l+42; i++)
t.insertAt(i, "Foo");
for (int i=l; i < l+42; i +=2)
t.remove(i);
}
for (int i=0; i < 4200; i+=5)
cout << t.get(i, "None");
cout << "Done!" << endl;
}
void Inquire(string Licensestr, HashTable<LicenseType, BikePtr>& ht){
LicenseType License(Licensestr);
BikePtr* bikeMetaPtr = ht.get(License);
if( bikeMetaPtr ) {
BikePtr bike = *bikeMetaPtr;
xStationType station = bike->Station;
ClassType Class = bike->Class;
int mileage = bike->Mileage;
cout << setw(15) << "License" << setw(15) << "Mileage"<<setw(15) << "Class" << setw(15) << "Station"<<endl;
cout<<"============================================================"<< endl;
cout << setw(11) << License << setw(15) << mileage<<setw(15) << classToStr(Class) << setw(15) << stationTypeToString(station) << endl << endl;
}
else {
cout << "Bike " << Licensestr << " does not belong to our company." << endl;
}
}
int Returns(xStationType statName, LicenseType license, int mile, HashTable<LicenseType, BikePtr>&ht, Graph &stationMap) {
BikePtr* bikeMetaPtr = ht.get(license);
if( bikeMetaPtr ) {
BikePtr bike = *bikeMetaPtr;
//bike->Status=Free;
vector<int> prev = stationMap.dijkstra(bike->Station);
forward_list<int> shortest_path = stationMap.getPath(prev, statName);
int dist=0;
if( ! shortest_path.empty() ) {
for(forward_list<int>::iterator it = shortest_path.begin(); it != shortest_path.end();) {
int from_tmp = *it;
forward_list<int>::iterator it_next = it;
it_next++;
if( it_next != shortest_path.end() ) {
int to_tmp = *(it_next);
dist += stationMap.distance(from_tmp, to_tmp);
}
it = it_next;
}
}
int charge=0;
int tmp=mile-bike->Mileage;
if(tmp>dist){
switch(bike->Class){
case 0:
charge=tmp*40;
break;
case 1:
charge=tmp*30;
break;
case 2:
charge=tmp*20;
break;
case 3:
charge=tmp*25;
break;
}
}
else{
switch(bike->Class){
case 0:
charge=tmp*30;
break;
case 1:
charge=tmp*25;
break;
case 2:
charge=tmp*15;
break;
case 3:
charge=tmp*20;
break;
}
}
bike->Mileage=mile;
int index = Station[bike->Station].HRent.find(bike, &licenseComp);
Station[bike->Station].HRent.remove(index);
Station[bike->Station].Nets[bike->Class] += charge;
bike->Status = Free;
Station[bike->Station].add(bike);
cout<<"Rental charge for this bike is "<<charge<<"."<<endl;
}
return 0;
}
void LoopReductor::reduce(VirtualCFG *vcfg, CFG *cfg) {
HashTable<BasicBlock*,BasicBlock*> map;
map.put(cfg->entry(), vcfg->entry());
map.put(cfg->exit(),vcfg->exit());
idx = 1;
/* duplicate the basic blocks */
for (CFG::BBIterator bb(cfg); bb; bb++) {
if (!bb->isEnd()) {
BasicBlock *vbb = new VirtualBasicBlock(*bb);
INDEX(vbb) = idx;
idx++;
map.put(bb, vbb);
vcfg->addBB(vbb);
}
}
INDEX(vcfg->exit()) = idx;
idx++;
/* connect edges */
for (CFG::BBIterator bb(cfg); bb; bb++) {
for (BasicBlock::OutIterator edge(bb); edge; edge++) {
if (edge->kind() == Edge::CALL) {
BasicBlock *vsource = map.get(edge->source(), NULL);
CFG *vcalled = vcfgvec.get(INDEX(edge->calledCFG()));
ASSERT(vsource && vcalled);
Edge *vedge = new Edge(vsource, vcalled->entry(), Edge::CALL);
CALLED_CFG(vedge) = vcalled;
} else {
BasicBlock *vsource = map.get(edge->source(), NULL);
BasicBlock *vtarget = map.get(edge->target(), NULL);
ASSERT(vsource && vtarget);
new Edge(vsource, vtarget, edge->kind());
}
}
}
Vector<BasicBlock*> *ancestors = new Vector<BasicBlock*>();
for (CFG::BBIterator bb(vcfg); bb; bb++) {
IN_LOOPS(bb) = new dfa::BitSet(vcfg->countBB());
}
/* Do the Depth-First Search, compute the ancestors sets, and mark loop headers */
depthFirstSearch(vcfg->entry(), ancestors);
/* Collect all loop headers in a bitset */
/*
for (CFG::BBIterator bb(vcfg); bb; bb++)
if (LOOP_HEADER(bb)) {
realhdr.add(bb->number());
}
*/
/*
HashTable<int, BasicBlock*> hdrmap;
Vector<BasicBlock*> dups;
*/
bool done = false;
while (!done) {
done = true;
for (CFG::BBIterator bb(vcfg); bb; bb++) {
Vector<Edge*> toDel;
BasicBlock *duplicate = NULL;
for (BasicBlock::InIterator edge(bb); edge; edge++) {
/* compute loops entered by the edge */
dfa::BitSet enteredLoops(**IN_LOOPS(bb));
enteredLoops.remove(**IN_LOOPS(edge->source()));
/* The edge is a regular entry if it enters one loop, and edge->target() == loop header */
if (!((enteredLoops.count() == 0) || ((enteredLoops.count() == 1) && (enteredLoops.contains(bb->number()))))) {
if (!duplicate) {
duplicate = new VirtualBasicBlock(bb);
ASSERT(DUPLICATE_OF(bb) == NULL);
DUPLICATE_OF(bb) = duplicate;
INDEX(duplicate) = idx;
idx++;
vcfg->addBB(duplicate);
IN_LOOPS(duplicate) = new dfa::BitSet(**IN_LOOPS(edge->source()));
for (BasicBlock::OutIterator outedge(bb); outedge; outedge++) {
if (DUPLICATE_OF(outedge->target())) {
new Edge(duplicate, DUPLICATE_OF(outedge->target()), outedge->kind());
} else {
new Edge(duplicate, outedge->target(), outedge->kind());
}
}
}
done = false;
new Edge(edge->source(), duplicate, edge->kind());
toDel.add(edge);
}
}
for (Vector<Edge*>::Iterator edge(toDel); edge; edge++)
delete *edge;
}
}
delete ancestors;
}
int main(int argc, char *argv[])
{
//checks to see correct number of arguments are passed in
if(argc != 2)
cerr << "Not correct number of arguments passed in." << endl;
//creates a hash table
HashTable htable;
vector<string> nameVector;
int i, dayNum, monthNum, yearNum;
string day, month, year;
ifstream infile(argv[1]);
if(!infile.is_open())
cout << "Could not open the file." << endl;
else
{
string line;
string name;
int count = 0;
while(getline(infile, line))
{
stringstream instream(line);
getline(instream, name, ',');
getline(instream, month, '/');
getline(instream, day, '/');
getline(instream, year);
Date d(atoi(month.c_str()), atoi(day.c_str()), atoi(year.c_str()));
htable.insert(d, name);
}
}
string wholeDate;
//get the initial date from the user
cout << "Please enter a date (mm/dd/yyyy) or 0 when finished: " ;
cin >> wholeDate;
//parse the initial date
stringstream newinstream(wholeDate);
getline(newinstream, month, '/');
getline(newinstream, day, '/');
getline(newinstream, year);
dayNum = atoi(day.c_str());
monthNum = atoi(month.c_str());
yearNum = atoi(year.c_str());
while(dayNum != 0 && monthNum != 0 && yearNum != 0)
{
Date getDate(monthNum, dayNum, yearNum);
nameVector = htable.get(getDate);
if(nameVector.size() == 0)
cout << "No names found for that date" << endl;
else
{
cout << "Number of names for date: " << month << "/" << day << "/" << year << ": " << nameVector.size()<< endl;
for(i = 0; i < nameVector.size(); i++)
cout << nameVector[i] << endl;
}
//get the next date from the user
cout << "Enter another date or 0 when finished: " ;
cin >> wholeDate;
//parse the next date
stringstream newinstream(wholeDate);
getline(newinstream, day, '/');
getline(newinstream, month, '/');
getline(newinstream, year);
dayNum = atoi(day.c_str());
monthNum = atoi(month.c_str());
yearNum = atoi(year.c_str());
}
return 0;
}
int main(int argc, char** arvg){
srand(time(NULL));
vector <int> v;
BSTree* root = new BSTree();
HashTable *ht = new HashTable();
int key, counter = 0;
initValues(v, *root, *ht);
cout << "Vector: " << endl;
sort(v.begin(), v.end());
printVector(v);
cout << "Binary Search Tree: " << endl;
root->print();
cout << "Hash table: " << endl;
ht->printHashTable();
cout << "Insert a key to search for: ";
cin >> key;
cout << endl << endl << "-------------Sequential Search-------------"
<< endl << endl;
sequentialSearch(v, key, counter);
std::string seq = "Number of iteractions from the Sequential Search: ";
seq += std::to_string(counter);
cout << seq << endl;
cout << endl << endl << "-------------Binary Search-------------"
<< endl << endl;
counter = 0;
binarySearch(v, key, counter, 0, size-1);
std::string bin = "Number of iteractions from the Binary Search: ";
bin += std::to_string(counter);
cout << bin << endl;
cout << endl << endl << "-------------Binary Search Tree-------------"
<< endl << endl;
counter = 0;
root->search(key, counter);
cout << endl << endl << "-------------Hash Table-------------"
<< endl << endl;
counter = 0;
ht->get(key, counter);
std::string hash = "Number of iteractions from the Hash Table: ";
hash += std::to_string(counter);
cout << hash << endl;
cout << endl << endl << "-------------Destroying Structures-------------"
<< endl << endl;
delete root;
delete ht;
getchar();
return 0;
}
/**
* Find a type by its name.
* @param name Type name.
* @return Found type or NULL.
*/
AbstractType *AbstractType::getType(CString name) {
return types.get(name, 0);
}
int testHashTable()
{
HashTable<uint64_t *,uint64_t> *hashTable;
std::vector<uint64_t> verify;
hashTable = new HashTable<uint64_t *,uint64_t>(glbTestSize);
uint64_t *value;
cout << "\nTesting HashTable.\n";
verify.resize(glbTestSize);
for (int ix = 0; ix < glbTestSize; ix++)
{
do
{
value = new uint64_t(random());
}
while (hashTable->get(*value) == NULL);
hashTable->insert(value, *value);
verify[ix] = *value;
}
for (int ix = 0; ix < glbTestSize; ix++)
{
if (*hashTable->get(verify[ix]) != verify[ix])
{
hashTable->get(verify[ix]);
cout << "Index ";
cout << ix;
cout << " does not match!\n";
//return -1;
}
//if ((ix % 4) == 3) {
// hashTable->remove(index);
//}
}
for (int ix = 0; ix < glbTestSize; ix++)
{
if (*hashTable->get(verify[ix]) != verify[ix])
{
cout << "Index ";
cout << ix;
cout << " does not match!\n";
return -1;
}
hashTable->remove(verify[ix]);
//if ((index % 4) != 3) {
// hashTable->remove(index);
//}
}
delete hashTable;
cout << "HashTable:Done\n";
return 0;
}
void GeneticLabratory::setInitialCraftingValues(TangibleObject* prototype, ManufactureSchematic* manufactureSchematic, int assemblySuccess) {
if(manufactureSchematic == NULL || manufactureSchematic->getDraftSchematic() == NULL)
return;
ManagedReference<DraftSchematic* > draftSchematic = manufactureSchematic->getDraftSchematic();
CraftingValues* craftingValues = manufactureSchematic->getCraftingValues();
float value, maxPercentage, currentPercentage, weightedSum;
String itemName;
// These 2 values are pretty standard, adding these
itemName = "xp";
value = float(draftSchematic->getXpAmount());
craftingValues->addExperimentalProperty("", itemName, value, value, 0, true, CraftingManager::OVERRIDECOMBINE);
itemName = "complexity";
value = manufactureSchematic->getComplexity();
craftingValues->addExperimentalProperty("", itemName, value, value, 0, true, CraftingManager::OVERRIDECOMBINE);
float modifier = calculateAssemblyValueModifier(assemblySuccess);
// Cast component to genetic
if (!prototype->isComponent())
return;
GeneticComponent* genetic = cast<GeneticComponent*>(prototype);
HashTable<String, ManagedReference<DnaComponent*> > slots;
for (int i = 0; i < manufactureSchematic->getSlotCount(); ++i) {
// Dna Component Slots
Reference<IngredientSlot* > iSlot = manufactureSchematic->getSlot(i);
ComponentSlot* cSlot = cast<ComponentSlot*>(iSlot.get());
ManagedReference<TangibleObject*> tano = cSlot->getPrototype();
ManagedReference<DnaComponent*> component = cast<DnaComponent*>( tano.get());
slots.put(cSlot->getSlotName(),component);
}
// At this point we have all the DNA slots. Update the craftingvalue accordingly
DnaComponent* phy = slots.get("physique_profile").get();
DnaComponent* pro = slots.get("prowess_profile").get();
DnaComponent* men = slots.get("mental_profile").get();
DnaComponent* psy = slots.get("psychological_profile").get();
DnaComponent* agr = slots.get("aggression_profile").get();
uint32 harMax, fortMax, endMax,intMax, dexMax,cleMax,depMax,couMax,fieMax,powMax;
fortMax = applyFormula(phy->getForititude(),pro->getForititude(),men->getForititude(),psy->getForititude(),agr->getForititude(),PHYSIQUE);
harMax = applyFormula(phy->getHardiness(),pro->getHardiness(),men->getHardiness(),psy->getHardiness(),agr->getHardiness(),PHYSIQUE);
dexMax = applyFormula(phy->getDexterity(),pro->getDexterity(),men->getDexterity(),psy->getDexterity(),agr->getDexterity(),PROWESS);
endMax = applyFormula(phy->getEndurance(),pro->getEndurance(),men->getEndurance(),psy->getEndurance(),agr->getEndurance(),PROWESS);
intMax = applyFormula(phy->getIntellect(),pro->getIntellect(),men->getIntellect(),psy->getIntellect(),agr->getIntellect(),MENTAL);
cleMax = applyFormula(phy->getCleverness(),pro->getCleverness(),men->getCleverness(),psy->getCleverness(),agr->getCleverness(),MENTAL);
depMax = applyFormula(phy->getDependency(),pro->getDependency(),men->getDependency(),psy->getDependency(),agr->getDependency(),PHYSCHOLOGICAL);
couMax = applyFormula(phy->getCourage(),pro->getCourage(),men->getCourage(),psy->getCourage(),agr->getCourage(),PHYSCHOLOGICAL);
fieMax = applyFormula(phy->getFierceness(),pro->getFierceness(),men->getFierceness(),psy->getFierceness(),agr->getFierceness(),AGRESSION);
powMax = applyFormula(phy->getPower(),pro->getPower(),men->getPower(),psy->getPower(),agr->getPower(),AGRESSION);
uint32 fortMin,endMin,harMin,intMin,dexMin,cleMin,depMin,couMin,fieMin,powMin;
fortMin = calcMin(fortMax);
harMin = calcMin(harMax);
dexMin = calcMin(dexMax);
endMin = calcMin(endMax);
intMin = calcMin(intMax);
cleMin = calcMin(cleMax);
depMin = calcMin(depMax);
couMin = calcMin(couMax);
fieMin = calcMin(fieMax);
powMin = calcMin(powMax);
float blast, energy, kinetic,heat,cold,electric,acid,stun,saber;
blast = applyFormula(phy->getBlast(),pro->getBlast(),men->getBlast(),psy->getBlast(),agr->getBlast(),PHYSIQUE);
kinetic = applyFormula(phy->getKinetic(),pro->getKinetic(),men->getKinetic(),psy->getKinetic(),agr->getKinetic(),PHYSIQUE);
energy = applyFormula(phy->getEnergy(),pro->getEnergy(),men->getEnergy(),psy->getEnergy(),agr->getEnergy(),PHYSIQUE);
heat = applyFormula(phy->getHeat(),pro->getHeat(),men->getHeat(),psy->getHeat(),agr->getHeat(),PHYSIQUE);
cold = applyFormula(phy->getCold(),pro->getCold(),men->getCold(),psy->getCold(),agr->getCold(),PHYSIQUE);
electric = applyFormula(phy->getElectric(),pro->getElectric(),men->getElectric(),psy->getElectric(),agr->getElectric(),PHYSIQUE);
acid = applyFormula(phy->getAcid(),pro->getAcid(),men->getAcid(),psy->getAcid(),agr->getAcid(),PHYSIQUE);
stun = applyFormula(phy->getStun(),pro->getStun(),men->getStun(),psy->getStun(),agr->getStun(),PHYSIQUE);
saber = applyFormula(phy->getSaber(),pro->getSaber(),men->getSaber(),psy->getSaber(),agr->getSaber(),PHYSIQUE);
craftingValues->addExperimentalProperty("expPhysiqueProfile","fortitude",fortMin,fortMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPhysiqueProfile","hardiness",harMin,harMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expProwessProfile","dexterity",dexMin,dexMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expProwessProfile","endurance",endMin,endMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expMentalProfile","intellect",intMin,intMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expMentalProfile","cleverness",cleMin,cleMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPsychologicalProfile","dependability",depMin,depMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPsychologicalProfile","courage",couMin,couMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expAggressionProfile","fierceness",fieMin,fieMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expAggressionProfile","power",powMin,powMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_kinetic",calcResistMin(kinetic,modifier),kinetic,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_blast",calcResistMin(blast,modifier),blast,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_energy",calcResistMin(energy,modifier),energy,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_heat",calcResistMin(heat,modifier),heat,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_cold",calcResistMin(cold,modifier),cold,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_electric",calcResistMin(electric,modifier),electric,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_acid",calcResistMin(acid,modifier),acid,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_stun",calcResistMin(stun,modifier),stun,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("","dna_comp_armor_saber",calcResistMin(saber,modifier),saber,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->setMaxPercentage("dna_comp_armor_kinetic",kinetic/100);
craftingValues->setMaxPercentage("dna_comp_armor_blast",blast/100);
craftingValues->setMaxPercentage("dna_comp_armor_energy",energy/100);
craftingValues->setMaxPercentage("dna_comp_armor_heat",heat/100);
craftingValues->setMaxPercentage("dna_comp_armor_cold",cold/100);
craftingValues->setMaxPercentage("dna_comp_armor_electric",electric/100);
craftingValues->setMaxPercentage("dna_comp_armor_acid",acid/100);
craftingValues->setMaxPercentage("dna_comp_armor_stun",stun/100);
craftingValues->setMaxPercentage("dna_comp_armor_saber",saber/100);
if (kinetic > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_kinetic",calcResistMin(kinetic,modifier)/kinetic);
else
craftingValues->setCurrentPercentage("dna_comp_armor_kinetic",kinetic/100);
if (blast > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_blast",calcResistMin(blast,modifier)/blast);
else
craftingValues->setCurrentPercentage("dna_comp_armor_blast",blast/100);
if (energy > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_energy",calcResistMin(energy,modifier)/energy);
else
craftingValues->setCurrentPercentage("dna_comp_armor_energy",energy/100);
if (heat > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_heat",calcResistMin(heat,modifier)/heat);
else
craftingValues->setCurrentPercentage("dna_comp_armor_heat",heat/100);
if (cold > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_cold",calcResistMin(cold,modifier)/cold);
else
craftingValues->setCurrentPercentage("dna_comp_armor_cold",cold/100);
if (electric > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_electric",calcResistMin(electric,modifier)/electric);
else
craftingValues->setCurrentPercentage("dna_comp_armor_electric",electric/100);
if (acid > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_acid",calcResistMin(acid,modifier)/acid);
else
craftingValues->setCurrentPercentage("dna_comp_armor_acid",acid/100);
if (stun > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_stun",calcResistMin(stun,modifier)/stun);
else
craftingValues->setCurrentPercentage("dna_comp_armor_stun",stun/100);
if (saber > 0)
craftingValues->setCurrentPercentage("dna_comp_armor_saber",calcResistMin(saber,modifier)/saber);
else
craftingValues->setCurrentPercentage("dna_comp_armor_saber",saber/100);
// Calc the max Percentage, vs Min Percentage
craftingValues->setMaxPercentage("fortitude",calcMaxPercentage(fortMax));
craftingValues->setCurrentPercentage("fortitude", getAssemblyPercentage(fortMin) * modifier);
craftingValues->setMaxPercentage("hardiness",calcMaxPercentage(harMax));
craftingValues->setCurrentPercentage("hardiness", getAssemblyPercentage(harMin) * modifier);
craftingValues->setMaxPercentage("dexterity",calcMaxPercentage(dexMax));
craftingValues->setCurrentPercentage("dexterity", getAssemblyPercentage(dexMin) * modifier);
craftingValues->setMaxPercentage("endurance",calcMaxPercentage(endMax));
craftingValues->setCurrentPercentage("endurance", getAssemblyPercentage(endMin) * modifier);
craftingValues->setMaxPercentage("intellect",calcMaxPercentage(intMax));
craftingValues->setCurrentPercentage("intellect", getAssemblyPercentage(intMin) * modifier);
craftingValues->setMaxPercentage("cleverness",calcMaxPercentage(cleMax));
craftingValues->setCurrentPercentage("cleverness", getAssemblyPercentage(cleMin) * modifier);
craftingValues->setMaxPercentage("dependability",calcMaxPercentage(depMax));
craftingValues->setCurrentPercentage("dependability", getAssemblyPercentage(depMin) * modifier);
craftingValues->setMaxPercentage("courage",calcMaxPercentage(couMax));
craftingValues->setCurrentPercentage("courage",getAssemblyPercentage(couMin) * modifier);
craftingValues->setMaxPercentage("fierceness",calcMaxPercentage(fieMax));
craftingValues->setCurrentPercentage("fierceness",getAssemblyPercentage(fieMin) * modifier);
craftingValues->setMaxPercentage("power",calcMaxPercentage(powMax));
craftingValues->setCurrentPercentage("power", getAssemblyPercentage(powMin) * modifier);
// Figure out the min percentage of the stats
int quality = (phy->getQuality() + pro->getQuality() + men->getQuality() + psy->getQuality() + agr->getQuality()) / 5;
bool ranged = false;
int odds = 0;
float menQual = 7 - men->getQuality();
float psyQual = 7 - psy->getQuality();
if (men->isRanged() || psy->isRanged()) {
int chance = System::random(100 - (assemblySuccess * 10)); // so amazing success 100, critical falure is 20
// did you roll exceed (7 - Quality) * 10 (VHQ is 0) so always works
if (chance > (menQual * 10) || chance > (psyQual * 10))
ranged = true;
}
odds = men->getQuality() * 100;
// check for specials here, then we have base assemble work completed.
// update crafting values, and/or experimentRow should handle resist calc changes. update crafting values should determine armor setup
String sp1 = pickSpecialAttack(agr->getSpecialAttackOne(),psy->getSpecialAttackOne(),phy->getSpecialAttackOne(),men->getSpecialAttackOne(),pro->getSpecialAttackOne(),odds);
String sp2 = pickSpecialAttack(psy->getSpecialAttackTwo(),pro->getSpecialAttackTwo(),agr->getSpecialAttackTwo(),men->getSpecialAttackTwo(),phy->getSpecialAttackTwo(),odds);
genetic->setSpecialAttackOne(sp1);
genetic->setSpecialAttackTwo(sp2);
genetic->setRanged(ranged);
genetic->setQuality(quality);
// determine avg sample levels to choose a level of this template for output generation
int level = (phy->getLevel() + pro->getLevel() + men->getLevel() + psy->getLevel() + agr->getLevel()) / 5;
genetic->setLevel(level);
craftingValues->recalculateValues(true);
}
void GeneticLabratory::setInitialCraftingValues(TangibleObject* prototype, ManufactureSchematic* manufactureSchematic, int assemblySuccess) {
if(manufactureSchematic == NULL || manufactureSchematic->getDraftSchematic() == NULL)
return;
ManagedReference<DraftSchematic* > draftSchematic = manufactureSchematic->getDraftSchematic();
CraftingValues* craftingValues = manufactureSchematic->getCraftingValues();
float value, maxPercentage, currentPercentage, weightedSum;
String itemName;
// These 2 values are pretty standard, adding these
itemName = "xp";
value = float(draftSchematic->getXpAmount());
craftingValues->addExperimentalProperty("", itemName, value, value, 0, true, CraftingManager::OVERRIDECOMBINE);
itemName = "complexity";
value = manufactureSchematic->getComplexity();
craftingValues->addExperimentalProperty("", itemName, value, value, 0, true, CraftingManager::OVERRIDECOMBINE);
float modifier = calculateAssemblyValueModifier(assemblySuccess);
// Cast component to genetic
if (!prototype->isComponent())
return;
GeneticComponent* genetic = cast<GeneticComponent*>(prototype);
HashTable<String, ManagedReference<DnaComponent*> > slots;
for (int i = 0; i < manufactureSchematic->getSlotCount(); ++i) {
// Dna Component Slots
Reference<IngredientSlot* > iSlot = manufactureSchematic->getSlot(i);
ComponentSlot* cSlot = cast<ComponentSlot*>(iSlot.get());
ManagedReference<TangibleObject*> tano = cSlot->getPrototype();
ManagedReference<DnaComponent*> component = cast<DnaComponent*>( tano.get());
slots.put(cSlot->getSlotName(),component);
}
// At this point we have all the DNA slots. Update the craftingvalue accordingly
DnaComponent* phy = slots.get("physique_profile").get();
DnaComponent* pro = slots.get("prowess_profile").get();
DnaComponent* men = slots.get("mental_profile").get();
DnaComponent* psy = slots.get("psychological_profile").get();
DnaComponent* agr = slots.get("aggression_profile").get();
// REVAMP FROM HERE DOWN.
// STEP 1. Determine Attributes
uint32 harMax, fortMax, endMax,intMax, dexMax,cleMax,depMax,couMax,fieMax,powMax;
// Calculate the max values i.e. the weighter resource avergae.
fortMax = Genetics::physiqueFormula(phy->getForititude(),pro->getForititude(),men->getForititude(),psy->getForititude(),agr->getForititude());
harMax = Genetics::physiqueFormula(phy->getHardiness(),pro->getHardiness(),men->getHardiness(),psy->getHardiness(),agr->getHardiness());
dexMax = Genetics::prowessFormula(phy->getDexterity(),pro->getDexterity(),men->getDexterity(),psy->getDexterity(),agr->getDexterity());
endMax = Genetics::prowessFormula(phy->getEndurance(),pro->getEndurance(),men->getEndurance(),psy->getEndurance(),agr->getEndurance());
intMax = Genetics::mentalFormula(phy->getIntellect(),pro->getIntellect(),men->getIntellect(),psy->getIntellect(),agr->getIntellect());
cleMax = Genetics::mentalFormula(phy->getCleverness(),pro->getCleverness(),men->getCleverness(),psy->getCleverness(),agr->getCleverness());
depMax = Genetics::physchologicalFormula(phy->getDependency(),pro->getDependency(),men->getDependency(),psy->getDependency(),agr->getDependency());
couMax = Genetics::physchologicalFormula(phy->getCourage(),pro->getCourage(),men->getCourage(),psy->getCourage(),agr->getCourage());
fieMax = Genetics::aggressionFormula(phy->getFierceness(),pro->getFierceness(),men->getFierceness(),psy->getFierceness(),agr->getFierceness());
powMax = Genetics::aggressionFormula(phy->getPower(),pro->getPower(),men->getPower(),psy->getPower(),agr->getPower());
// acknowledge any specials found in the experimentation line. this means specials will not modify later by experimentaiton as its an overlay value.
bool spBlast = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::BLAST);
bool spKinetic = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::KINETIC);
bool spEnergy = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::ENERGY);
bool spHeat = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::HEAT);
bool spCold = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::COLD);
bool spElectric = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::ELECTRICITY);
bool spAcid = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::ACID);
bool spStun = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::STUN);
bool spSaber = Genetics::hasASpecial(phy,pro,men,psy,agr,WeaponObject::LIGHTSABER);
// Calculate resists
// 1 percent: (1000 - 0) / 100.0f;
float blastMax, energyMax, kineticMax,heatMax,coldMax,electricMax,acidMax,stunMax,saberMax;
blastMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::BLAST,100.0f);
kineticMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::KINETIC,60.0f);
energyMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::ENERGY,60.0f);
heatMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::HEAT,100.0f);
coldMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::COLD,100.0f);
electricMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::ELECTRICITY,100.0f);
acidMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::ACID,100.0f);
stunMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::STUN,100.0f);
saberMax = Genetics::resistanceFormula(phy,pro,men,psy,agr,WeaponObject::LIGHTSABER,100.0f);
// lets clear the special bit if it moved to effective range.
if(saberMax == 0) {
spSaber = false;
saberMax = 100;
}
if (blastMax == 0) {
spBlast = false;
blastMax = 100;
}
if (kineticMax == 0) {
spKinetic = false;
kineticMax = 60;
}
if (energyMax == 0) {
spEnergy = false;
energyMax = 60;
}
if (heatMax == 0) {
spHeat = false;
heatMax = 100;
}
if (coldMax == 0) {
spCold = false;
coldMax = 100;
}
if (electricMax == 0) {
spElectric = false;
electricMax = 100;
}
if(acidMax == 0) {
spAcid = false;
acidMax = 100;
}
if(stunMax == 0) {
spStun = false;
stunMax = 100;
}
// Step 2. At this point we know the max values for all stats and we have calculated any armor specials needed
// So now we need to setup the min and initial values of stats and define the experimental attributes. // Ranges are 0 to 100 for any one of these
// set current value to be 70% less than max calculated as the experimentation range. i.e.
craftingValues->addExperimentalProperty("expPhysiqueProfile","fortitude",0,fortMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPhysiqueProfile","hardiness",0,harMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expProwessProfile","dexterity",0,dexMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expProwessProfile","endurance",0,endMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expMentalProfile","intellect",0,intMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expMentalProfile","cleverness",0,cleMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPsychologicalProfile","dependability",0,depMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expPsychologicalProfile","courage",0,couMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expAggressionProfile","fierceness",0,fieMax,0,false,CraftingManager::LINEARCOMBINE);
craftingValues->addExperimentalProperty("expAggressionProfile","power",0,powMax,0,false,CraftingManager::LINEARCOMBINE);
String title;
int armorBase = 0;
int effectiveness = 0;
for(int i=0;i<craftingValues->getExperimentalPropertySubtitleSize();i++) {
title = craftingValues->getExperimentalPropertySubtitle(i);
if (craftingValues->isHidden(title))
continue;
// We need to accoutn for assembly percentage. do some swapping around as well.
float maxValue = craftingValues->getMaxValue(title);
float initialValue = Genetics::initialValue(craftingValues->getMaxValue(title));
// determine max percentage
craftingValues->setMaxPercentage(title, maxValue/1000.0f);
craftingValues->setMaxValue(title,1000);
// using assembly to accoutn for a 1 +% increase
currentPercentage = getAssemblyPercentage(initialValue) * modifier;
//craftingValues->setMaxPercentage(title, maxPercentage);
craftingValues->setCurrentPercentage(title, currentPercentage);
if (title == "fortitude") {
armorBase = craftingValues->getCurrentValue(title);
}
}
int armorValue = armorBase/500;
effectiveness = (int)(((armorBase - (armorValue * 500)) / 50) * 5);
// Store off armor data
craftingValues->addExperimentalProperty("resists","dna_comp_armor_kinetic",spKinetic ? kineticMax : kineticMax < 0 ? -1 : effectiveness,kineticMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_blast",spBlast ? blastMax : blastMax < 0 ? -1 : effectiveness, blastMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_energy",spEnergy ? energyMax : energyMax < 0 ? -1 : effectiveness, energyMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_heat",spHeat ? heatMax : heatMax < 0 ? -1 : effectiveness ,heatMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_cold",spCold ? coldMax : coldMax < 0 ? -1 : effectiveness ,coldMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_electric",spElectric ? electricMax : electricMax < 0 ? -1 : effectiveness ,electricMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_acid",spAcid ? acidMax : acidMax < 0 ? -1 : effectiveness ,acidMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_stun",spStun ? stunMax : stunMax < 0 ? -1 : effectiveness ,stunMax,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("resists","dna_comp_armor_saber",spSaber ? saberMax : saberMax < 0 ? -1 : effectiveness ,saberMax,0,true,CraftingManager::OVERRIDECOMBINE);
// Store off special information
craftingValues->addExperimentalProperty("specials","kineticeffectiveness",spKinetic ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","blasteffectiveness",spBlast ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","energyeffectiveness",spEnergy ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","heateffectiveness",spHeat ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","coldeffectiveness",spCold ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","electricityeffectiveness",spElectric ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","acideffectiveness",spAcid ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","stuneffectiveness",spStun ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
craftingValues->addExperimentalProperty("specials","lightsabereffectiveness",spSaber ? 1: 0,1,0,true,CraftingManager::OVERRIDECOMBINE);
int quality = ( ((float)phy->getQuality() * 0.2)+ ((float)pro->getQuality()*0.2) + ((float)men->getQuality()*0.2) + ((float)psy->getQuality()*0.2) + ((float)agr->getQuality()*0.2));
bool ranged = false;
int odds = 0;
float menQual = men->getQuality() - 1;
float psyQual = psy->getQuality() - 1;
if (men->isRanged() || psy->isRanged()) {
int chance = System::random(100-(assemblySuccess * 10)); // so amazing success 100, critical falure is 20
// did you roll exceed (7 - Quality) * 10 (VHQ is 0) so always works
if (chance >= (menQual * 10) || chance >= (psyQual * 10))
ranged = true;
}
odds = quality * 100;
// check for specials here, then we have base assemble work completed.
// update crafting values, and/or experimentRow should handle resist calc changes. update crafting values should determine armor setup
String sp1 = pickSpecialAttack(agr->getSpecialAttackOne(),psy->getSpecialAttackOne(),phy->getSpecialAttackOne(),men->getSpecialAttackOne(),pro->getSpecialAttackOne(),odds,"defaultattack");
String sp2 = pickSpecialAttack(psy->getSpecialAttackTwo(),pro->getSpecialAttackTwo(),agr->getSpecialAttackTwo(),men->getSpecialAttackTwo(),phy->getSpecialAttackTwo(),odds,sp1);
genetic->setSpecialAttackOne(sp1);
genetic->setSpecialAttackTwo(sp2);
genetic->setRanged(ranged);
genetic->setQuality(quality);
// determine avg sample levels to choose a level of this template for output generation
int level = Genetics::physchologicalFormula(phy->getLevel(),pro->getLevel(),men->getLevel(), psy->getLevel() ,agr->getLevel());
genetic->setLevel(level);
craftingValues->recalculateValues(true);
}