public static void ToggleSelectedAccessoryForKitty(
KittyModel kitty,
AccessoryModel accessory
)
{
var kittyAccessoriesForKitty = KittyAccessoryService.GetModelsByKittyId(
kitty.id
);
// mutate the kittyAccessory objects to ensure only one in the
// group+subgroup is selected and save
foreach (var kittyAccessoryModel in kittyAccessoriesForKitty)
{
if (
kittyAccessoryModel.accessoryGroup == accessory.accessoryGroup &&
kittyAccessoryModel.accessorySubGroup == accessory.accessorySubGroup
)
{
if (kittyAccessoryModel.accessoryId == accessory.id)
{
kittyAccessoryModel.isSelected = !kittyAccessoryModel.isSelected;
}
else
{
kittyAccessoryModel.isSelected = false;
}
}
}
KittyAccessoryService.SaveMultiple(KittyAccessoryService.GetAll());
}
private void DefautKittySelection()
{
var kitties = KittyService.GetAll();
bool kittySelected = false;
KittyModel kittyUnlocked = null;
foreach (var kitty in kitties)
{
if (kitty.isSelected)
{
kittySelected = true;
}
if (kittyUnlocked == null && kitty.isUnlocked)
{
kittyUnlocked = kitty;
}
}
if (!kittySelected)
{
if (kittyUnlocked != null)
{
// set first kitty found that's unlocked to selected status
kittyUnlocked.isSelected = true;
}
else
{
// set random kitty to unlocked and selected
int randomKittyIndex = Random.Range(0, kitties.Count);
var randomKitty = kitties[randomKittyIndex];
randomKitty.isUnlocked = true;
randomKitty.isSelected = true;
}
}
KittyService.SaveMultiple(kitties);
}
public string GetFormattedKeyFromKittyAndAccessoryCombination(
KittyModel kittyModel,
AccessoryModel accessoryModel
)
{
return(kittyModel.id + "_" + accessoryModel.id);
}
private void FetchAccessoryImages()
{
// deactivate all accessory game objects
foreach (var partDict in this.displayLookup.Values)
{
foreach (var image in partDict.Values)
{
image.gameObject.SetActive(false);
}
}
// TODO: implementation of this method is unoptimized, utilize lookup batching in a future refactor
KittyModel kittyModel = KittyService.GetSelected();
foreach (var kittyAccessoryModel in KittyAccessoryService.GetModelsByKittyId(kittyModel.id))
{
if (kittyAccessoryModel.isSelected)
{
// lookup accessory model
var accessoryModel = AccessoryService.GetModelsByIds(new List <string> {
kittyAccessoryModel.accessoryId
})[0];
// lookup sprite
Sprite accessorySprite = AssetService.GetSprite(accessoryModel.primaryAssetAddress);
// lookup display object image and assign sprite
Image displayImage = this.displayLookup[kittyAccessoryModel.accessoryGroup][kittyAccessoryModel.accessorySubGroup];
displayImage.sprite = accessorySprite;
displayImage.gameObject.SetActive(true);
}
}
}
// INTERFACE METHODS
// IMPLEMENTATION METHODS
private void FetchKittyImage()
{
KittyModel kittyModel = KittyService.GetSelected();
Sprite kittySprite = AssetService.GetSprite(kittyModel.primaryAssetAddress);
kittyImage.sprite = kittySprite;
}
// chose, at random, one item among the
// locked accessories and locked kitties for unlock
private void UnlockRandomKittyOrAccessory()
{
// chance list for calculating selection of kitty or accessory for unlock
var selectBetweenList = new List <int>();
// gather objects
var allKitties = KittyService.GetAll();
var selectedKitty = KittyService.GetSelected();
var accessoriesForKitty = AccessoryService.GetAccessoriesForKitty(selectedKitty);
// filter for locked kitties and accessories
var lockedKitties = new List <KittyModel>();
foreach (var kitty in allKitties)
{
if (!kitty.isUnlocked)
{
lockedKitties.Add(kitty);
selectBetweenList.Add(1);
}
}
var lockedAccessoriesForKitty = new List <AccessoryModel>();
foreach (var accessory in accessoriesForKitty)
{
var kittyAccessory = KittyAccessoryService.GetModelByKittyAndAccessoryCombination(
selectedKitty,
accessory
);
if (!kittyAccessory.isUnlocked)
{
lockedAccessoriesForKitty.Add(accessory);
selectBetweenList.Add(2);
}
}
// select whether kitty or accessory will be unlocked
int randomSelectionIndex = Random.Range(0, selectBetweenList.Count);
int selectedType = selectBetweenList[randomSelectionIndex];
if (selectedType == 1)
{
// unlock random locked kitty
randomSelectionIndex = Random.Range(0, lockedKitties.Count);
this.unlockedKittyModel = lockedKitties[randomSelectionIndex];
this.unlockedKittyModel.isUnlocked = true;
KittyService.Save(this.unlockedKittyModel);
}
else
{
// unlock random accessory for kitty
randomSelectionIndex = Random.Range(0, lockedAccessoriesForKitty.Count);
this.unlockedAccessoryModel = lockedAccessoriesForKitty[randomSelectionIndex];
var kittyAccessoryToUnlock = KittyAccessoryService.GetModelByKittyAndAccessoryCombination(
selectedKitty,
this.unlockedAccessoryModel
);
kittyAccessoryToUnlock.isUnlocked = true;
KittyAccessoryService.Save(kittyAccessoryToUnlock);
}
}
public static void Save(KittyModel model)
{
var modelsToSave = new List <KittyModel>()
{
model
};
KittyService.SaveMultiple(modelsToSave);
}
// IMPLEMENTATION METHODS
private void KittyStartupProcesses()
{
List <Sprite> kittySprites =
Resources.LoadAll("Kitty", typeof(Sprite))
.Cast <Sprite>()
.ToList();
var kittiesToSave = new List <KittyModel>();
foreach (var kittySprite in kittySprites)
{
// create kitty model if it doesn't yet exist
var kittyModel = KittyService.GetModelByAssetName(kittySprite.name);
if (kittyModel == null)
{
kittyModel = new KittyModel(
System.Guid.NewGuid().ToString(),
kittySprite.name,
KittyService.GetFormattedAssetAddress(kittySprite.name),
KittyService.GetFormattedThumbAssetAddress(kittySprite.name),
false,
false
);
kittiesToSave.Add(kittyModel);
}
// register assets
AssetService.SetSprite(
KittyService.GetFormattedAssetAddress(kittySprite.name),
kittySprite
);
}
// save thumb kitty sprites to Asset service
List <Sprite> kittyThumbSprites =
Resources.LoadAll("KittyThumb", typeof(Sprite))
.Cast <Sprite>()
.ToList();
foreach (var kittyThumbSprite in kittyThumbSprites)
{
string thumbAddress = KittyService.GetFormattedThumbAssetAddress(
kittyThumbSprite.name,
true
);
AssetService.SetSprite(
thumbAddress,
kittyThumbSprite
);
}
// insert kitties to be saved
KittyService.SaveMultiple(kittiesToSave);
}
public static List <AccessoryModel> GetAccessoriesForKitty(
KittyModel kittyModel
)
{
var selectedAccessoryIds = new List <string>();
foreach (var kittyAccessoryModel in KittyAccessoryService.GetAll())
{
if (kittyAccessoryModel.kittyId == kittyModel.id)
{
selectedAccessoryIds.Add(kittyAccessoryModel.accessoryId);
}
}
return(AccessoryService.GetModelsByIds(selectedAccessoryIds));
}
// SERVICE FOR KITTY -> ACCESSORY RELATIONSHIPS
public static KittyAccessoryModel GetModelByKittyAndAccessoryCombination(
KittyModel kittyModel,
AccessoryModel accessoryModel
)
{
KittyAccessoryData kittyAccessoryData = GameManager.instance.kittyAccessoryData;
string key = kittyAccessoryData.GetFormattedKeyFromKittyAndAccessoryCombination(
kittyModel,
accessoryModel
);
var keyToModel = kittyAccessoryData.GetKeyToModel();
if (keyToModel.ContainsKey(key))
{
return(keyToModel[key]);
}
return(null);
}
public static void SetSelected(KittyModel model)
{
// deselect currently selected
var previouslySelectedKitty = KittyService.GetSelected();
if (model.id == previouslySelectedKitty.id)
{
// Debug.Log("attempting to select already selected kitty: " + model.primaryAssetAddress);
return;
}
previouslySelectedKitty.isSelected = false;
// set selected
model.isSelected = true;
// batch save models
KittyService.SaveMultiple(
new List <KittyModel>()
{
previouslySelectedKitty, model
}
);
}
