private void KittyAccessoryStartupProcesses()
{
var kittyModels = KittyService.GetAll();
var accessoryModels = AccessoryService.GetAll();
// create the kitty-accessory models if they don't yet exist
var kittyAccessoriesToSave = new List <KittyAccessoryModel>();
foreach (var kittyModel in kittyModels)
{
foreach (var accessoryModel in accessoryModels)
{
var kittyAccessoryModel =
KittyAccessoryService.GetModelByKittyAndAccessoryCombination(
kittyModel,
accessoryModel
);
if (kittyAccessoryModel == null)
{
kittyAccessoryModel = new KittyAccessoryModel(
kittyModel.id,
accessoryModel.id,
accessoryModel.accessoryGroup,
accessoryModel.accessorySubGroup,
false,
false
);
kittyAccessoriesToSave.Add(kittyAccessoryModel);
}
}
}
// insert kitty-accessories to be saved
KittyAccessoryService.SaveMultiple(kittyAccessoriesToSave);
}
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);
}
// INTERFACE METHODS
// IMPLEMENTATION METHODS
private void FetchKittyImage()
{
KittyModel kittyModel = KittyService.GetSelected();
Sprite kittySprite = AssetService.GetSprite(kittyModel.primaryAssetAddress);
kittyImage.sprite = kittySprite;
}
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);
}
}
}
void Start()
{
var kittyModel = KittyService.GetSelected();
Sprite sprite = AssetService.GetSprite(kittyModel.thumbAssetAddress);
kittyThumbSprite.sprite = sprite;
}
public void Get_BigBigId_ReturnsNullValue()
{
var target = new KittyService();
var data = target.GetKitty(99999999).Result;
Assert.IsNull(data);
}
public void Query_ReturnsKittyData()
{
var target = new KittyService();
var data = target.GetKitties(new KittyQueryRequestMessage()).Result;
TestContext.WriteLine(JsonConvert.SerializeObject(data));
}
// 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);
}
public void Get_GoodId_ReturnsKittyData()
{
var target = new KittyService();
var data = target.GetKitty(435234).Result;
Assert.IsNotNull(data);
TestContext.WriteLine(JsonConvert.SerializeObject(data));
}
public static KittyModel GetModelById(string id)
{
foreach (var model in KittyService.GetAll())
{
if (id == model.id)
{
return(model);
}
}
return(null);
}
public static KittyModel GetSelected()
{
foreach (var model in KittyService.GetAll())
{
if (model.isSelected)
{
return(model);
}
}
return(null);
}
// 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);
}
// INTERFACE METHODS
// IMPLEMENTATION METHODS
private void RenderAccessoryItems()
{
var selectedKittyModel = KittyService.GetSelected();
// clear the exising accessory items in the scroll list
foreach (var accessoryItem in this.accessoryItems)
{
GameObject.Destroy(accessoryItem);
}
this.accessoryItems.Clear();
// setup kitty-accessory models for lookups
var accessoryIdToKittyAccessoryModel = new Dictionary <string, KittyAccessoryModel>();
foreach (var kittyAccessoryModel in KittyAccessoryService.GetModelsByKittyId(selectedKittyModel.id))
{
accessoryIdToKittyAccessoryModel.Add(kittyAccessoryModel.accessoryId, kittyAccessoryModel);
}
List <AccessoryModel> accessories = AccessoryService.GetAll();
bool viewAll = GameManager.instance.adminControl.showAllKittiesAndAccessories;
Debug.Log("View all accessories: " + viewAll.ToString());
foreach (var accessoryModel in accessories)
{
var kittyAccessoryModel = accessoryIdToKittyAccessoryModel[accessoryModel.id];
// create accessory item per unlocked accessory item for currently selected kitty
if (kittyAccessoryModel.isUnlocked || viewAll)
{
GameObject accessoryScrollContentItem = Instantiate(
accessoryScrollContentItemPrefab,
scrollContent.transform
);
var script = accessoryScrollContentItem.GetComponent <AccessoryScrollContentItemScript>();
Sprite sprite = AssetService.GetSprite(accessoryModel.thumbAssetAddress);
if (sprite != null)
{
script.accessoryImage.sprite = sprite;
}
else
{
Debug.Log("Sprite not found at address: " + accessoryModel.thumbAssetAddress);
}
script.kittyModel = selectedKittyModel;
script.accessoryModel = accessoryModel;
this.accessoryItems.Add(accessoryScrollContentItem);
}
}
}
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
}
);
}
// UNITY HOOKS
void Start()
{
List <KittyModel> kitties = KittyService.GetAll();
bool viewAll = GameManager.instance.adminControl.showAllKittiesAndAccessories;
Debug.Log("View all kitties: " + viewAll.ToString());
foreach (var kittyModel in kitties)
{
if (kittyModel.isUnlocked || viewAll)
{
GameObject kittyScrollContentItem = Instantiate(
kittyScrollContentItemPrefab,
scrollContent.transform
);
Sprite sprite = AssetService.GetSprite(kittyModel.thumbAssetAddress);
var script = kittyScrollContentItem.GetComponent <KittyScrollContentItemScript>();
script.kittyImage.sprite = sprite;
script.kittyModel = kittyModel;
}
}
}
public void SelectKitty()
{
KittyService.SetSelected(this.kittyModel);
GameManager.instance.unityEvents.kittySelectEvent.Invoke();
}
