public void accept(CombineRelationship rel)
{
// Add the combine relationship to the map
if (!_relationshipMap.ContainsKey(rel.ingredient1Name))
{
_relationshipMap[rel.ingredient1Name] = new Dictionary <string, IRelationship>();
}
_relationshipMap[rel.ingredient1Name][rel.ingredient2Name] = rel;
if (!_relationshipMap.ContainsKey(rel.ingredient2Name))
{
_relationshipMap[rel.ingredient2Name] = new Dictionary <string, IRelationship>();
}
_relationshipMap[rel.ingredient2Name][rel.ingredient1Name] = rel;
// Make sure our reward item is included in the list of item names
_itemNames.Add(rel.resultItem.Name);
}
protected void addAuxiliaryRelationship(string name1, string name2)
{
IRelationship relToAdd = null;
DBItem dbitem1 = Database.Instance.getItem(name1);
DBItem dbitem2 = Database.Instance.getItem(name2);
// Figure out if one of the items can be inserted in the other
if (dbitem1.propertyExists("container") && (bool)dbitem1.getProperty("container") &&
dbitem1.propertyExists("filledby") && (dbitem1.getProperty("filledby") as List <string>).Contains(name2))
{
relToAdd = new InsertionRelationship(name2, 0, name1, 0);
}
if (relToAdd == null)
{
if (dbitem2.propertyExists("container") && (bool)dbitem2.getProperty("container") &&
dbitem2.propertyExists("filledby") && (dbitem2.getProperty("filledby") as List <string>).Contains(name1))
{
relToAdd = new InsertionRelationship(name1, 0, name2, 0);
}
}
// Next, try combine relationships
if (relToAdd == null)
{
if (dbitem1.propertyExists("makes"))
{
List <KeyValuePair <string, string> > makes = new List <KeyValuePair <string, string> >((List <KeyValuePair <string, string> >)dbitem1.getProperty("makes"));
Globals.shuffle(makes);
foreach (KeyValuePair <string, string> recipe in makes)
{
if (recipe.Key == name2)
{
if (!Database.Instance.itemExists(recipe.Value))
{
continue;
}
DBItem dbResult = Database.Instance.getItem(recipe.Value);
if (dbResult.Spawned)
{
continue;
}
PuzzleItem resultItem = dbResult.spawnItem();
relToAdd = new CombineRelationship(name1, 0, name2, 0, resultItem);
break;
}
}
}
}
if (relToAdd == null)
{
if (dbitem2.propertyExists("makes"))
{
List <KeyValuePair <string, string> > makes = new List <KeyValuePair <string, string> >((List <KeyValuePair <string, string> >)dbitem2.getProperty("makes"));
Globals.shuffle(makes);
foreach (KeyValuePair <string, string> recipe in makes)
{
if (recipe.Key == name1)
{
if (!Database.Instance.itemExists(recipe.Value))
{
continue;
}
DBItem dbResult = Database.Instance.getItem(recipe.Value);
if (dbResult.Spawned)
{
continue;
}
PuzzleItem resultItem = dbResult.spawnItem();
relToAdd = new CombineRelationship(name1, 0, name2, 0, resultItem);
break;
}
}
}
}
// Finally try property change relationships
if (relToAdd == null)
{
if (dbitem1.propertyExists("changes"))
{
List <KeyValuePair <string, string> > changes = new List <KeyValuePair <string, string> >();
Dictionary <string, List <string> > changesDict = (Dictionary <string, List <string> >)dbitem1.getProperty("changes");
foreach (string changeProp in changesDict.Keys)
{
foreach (string changeVal in changesDict[changeProp])
{
changes.Add(new KeyValuePair <string, string>(changeProp, changeVal));
}
}
Globals.shuffle(changes);
foreach (KeyValuePair <string, string> change in changes)
{
// Check if the property is mutable and allows our value
if (!dbitem2.propertyExists("mutables") || !((List <string>)dbitem2.getProperty("mutables")).Contains(change.Key))
{
continue;
}
if (!dbitem2.propertyExists(change.Key) || !((List <string>)dbitem2.getProperty(change.Key)).Contains(change.Value))
{
continue;
}
relToAdd = new PropertyChangeRelationship(name2, 0, name1, 0, change.Key, change.Value);
break;
}
}
}
if (relToAdd == null)
{
if (dbitem2.propertyExists("changes"))
{
List <KeyValuePair <string, string> > changes = new List <KeyValuePair <string, string> >();
Dictionary <string, List <string> > changesDict = (Dictionary <string, List <string> >)dbitem2.getProperty("changes");
foreach (string changeProp in changesDict.Keys)
{
foreach (string changeVal in changesDict[changeProp])
{
changes.Add(new KeyValuePair <string, string>(changeProp, changeVal));
}
}
Globals.shuffle(changes);
foreach (KeyValuePair <string, string> change in changes)
{
// Check if the property is mutable and allows our value
if (!dbitem1.propertyExists("mutables") || !((List <string>)dbitem1.getProperty("mutables")).Contains(change.Key))
{
continue;
}
if (!dbitem1.propertyExists(change.Key) || !((List <string>)dbitem1.getProperty(change.Key)).Contains(change.Value))
{
continue;
}
relToAdd = new PropertyChangeRelationship(name1, 0, name2, 0, change.Key, change.Value);
break;
}
}
}
if (relToAdd != null)
{
if (!_relationshipMap.ContainsKey(name1))
{
_relationshipMap[name1] = new Dictionary <string, IRelationship>();
}
_relationshipMap[name1][name2] = relToAdd;
if (!_relationshipMap.ContainsKey(name2))
{
_relationshipMap[name2] = new Dictionary <string, IRelationship>();
}
_relationshipMap[name2][name1] = relToAdd;
}
}
public void accept(CombineRelationship rel)
{
// Create a new spawn item for the new item
SpawnedPuzzleItem itemToSpawn = spawnItem(rel.resultItem);
// Now, need to figure out where to spawn the new item.
bool spawnInInventory = false, spawnAtLocation = false, spawnInItem1Container = false, spawnInItem2Container = false;
Vector2 locationToSpawn = Vector2.zero;
SpawnedPuzzleItem item1Container = _item1.parentItem;
SpawnedPuzzleItem item2Container = _item2.parentItem;
bool destroyItem1 = !_item1.propertyExists("destroyoncombine") || (bool)_item1.getProperty("destroyoncombine");
bool destroyItem2 = !_item2.propertyExists("destroyoncombine") || (bool)_item2.getProperty("destroyoncombine");
// If neither ingredient is destoyed, just spawn in the room
if (!destroyItem1 && !destroyItem2)
{
spawnAtLocation = false;
spawnInInventory = false;
spawnInItem1Container = false;
spawnInItem2Container = false;
}
else if (itemToSpawn.carryable && ((destroyItem1 && _item1.inInventory) || (destroyItem2 && _item2.inInventory)))
{
spawnInInventory = true;
}
// If the item is not carryable, have to spawn in room
else
{
spawnInInventory = false;
// Check if we can spawn in item1's container
if (destroyItem1 && _item1.insideItem && itemToSpawn.propertyExists("fills") && (itemToSpawn.getProperty("fills") as List <string>).Contains(item1Container.itemName))
{
spawnInItem1Container = true;
}
else if (destroyItem2 && _item2.insideItem && itemToSpawn.propertyExists("fills") && (itemToSpawn.getProperty("fills") as List <string>).Contains(item2Container.itemName))
{
spawnInItem2Container = true;
}
else if (destroyItem1 && !_item1.inInventory)
{
spawnAtLocation = true;
locationToSpawn = _item1.gridPos;
}
else if (destroyItem2 && !_item2.inInventory)
{
spawnAtLocation = true;
locationToSpawn = _item2.gridPos;
}
}
// Destroy items that need to be destroyed.
if (destroyItem1)
{
if (_item1.inInventory)
{
_item1.currentSlot.removeItem();
}
if (_item1.insideItem)
{
_item1.removeFromOtherItem();
}
_item1.die();
}
if (destroyItem2)
{
if (_item2.inInventory)
{
_item2.currentSlot.removeItem();
}
if (_item2.insideItem)
{
_item2.removeFromOtherItem();
}
_item2.die();
}
// Now finally spawn the item.
if (spawnInInventory)
{
itemToSpawn.init();
itemToSpawn.addToInventory();
}
else if (spawnInItem1Container)
{
itemToSpawn.init();
itemToSpawn.addToOtherItem(item1Container);
}
else if (spawnInItem2Container)
{
itemToSpawn.addToOtherItem(item2Container);
}
else if (spawnAtLocation)
{
_currentRoom.addPiece(itemToSpawn, locationToSpawn);
}
else
{
_currentRoom.addPiece(itemToSpawn);
}
// Play a sound
PlayState.instance.playAudio(PlayState.instance.pickupClip);
}
protected override bool spawnFilteredInputs(string outputName)
{
DBItem rewardDBItem = Database.Instance.getItem(outputName);
if (!rewardDBItem.propertyExists("madeby"))
{
if (_verbose)
{
Debug.Log("Failed to generate combine puzzle: Reward could not be the result of combination");
}
return(false);
}
List <KeyValuePair <string, string> > workingCombinations = rewardDBItem.getProperty("madeby") as List <KeyValuePair <string, string> >;
List <KeyValuePair <string, string> > filteredCombinations = filterWorkingCombinations(workingCombinations);
if (filteredCombinations.Count == 0)
{
if (_verbose)
{
Debug.Log("Failed to generate combine puzzle: No working combinations fit constraints");
}
return(false);
}
// Randomly shuffle our working combinations
BuildingBlock.shuffle(filteredCombinations);
// and try each combination
foreach (KeyValuePair <string, string> itemPair in filteredCombinations)
{
// Unpack the "Tuples"
string itemName1 = itemPair.Key;
string itemName2 = itemPair.Value;
PuzzleOutput possibleInput1 = _input1.generatePuzzle(itemName1);
PuzzleOutput possibleInput2 = _input2.generatePuzzle(itemName2);
if (possibleInput1 == null || possibleInput2 == null)
{
if (_verbose)
{
Debug.Log("Failed to generate combine puzzle using " + itemName1 + " and " + itemName2);
}
Debug.Log(string.Format("input1: {0}, input2: {1}", possibleInput1, possibleInput2));
_input1.despawnItems();
_input2.despawnItems();
continue;
}
else if (!BuildingBlock.areCarryable(new List <string>()
{
itemName1, itemName2
}, new List <BuildingBlock>()
{
_input1, _input2
}))
{
if (_verbose)
{
Debug.Log("Failed to generate combine puzzle using " + itemName1 + " and " + itemName2 + " because neither item is carryable to the other item.");
}
_input1.despawnItems();
_input2.despawnItems();
continue;
}
// Success!
else
{
if (_verbose)
{
Debug.Log("Successfully generated combine puzzle for " + outputName + " with " + itemName1 + " and " + itemName2);
}
// Add all the items spawned by our inputs
_itemsToSpawn.AddRange(possibleInput1.Items);
_itemsToSpawn.AddRange(possibleInput2.Items);
_relationshipsToSpawn.AddRange(possibleInput1.Relationships);
_relationshipsToSpawn.AddRange(possibleInput2.Relationships);
// Generate the essential combine relationship
CombineRelationship combine = new CombineRelationship(itemName1, _input1.outputSpawnIndex(), itemName2, _input2.outputSpawnIndex(), _spawnedOutput as PuzzleItem);
_relationshipsToSpawn.Add(combine);
return(true);
}
}
if (_verbose)
{
Debug.Log("Failed to generate combine puzzle: no working combinations worked!");
}
return(false);
}
