private void OnOpenButtonClick(string dataBaseOpenPath)
{
SceneDescriptor sceneDescriptor = SceneDescriptorsHelper.LoadFromFile(dataBaseOpenPath);
if (!String.IsNullOrEmpty(sceneDescriptor.sceneName))
{
scene = new GameObject(sceneDescriptor.sceneName).transform;
}
else
{
scene = new GameObject("Scene").transform;
}
scene.position = new Vector3(0, 0, 0);
SceneComponent sceneComponent = scene.gameObject.AddComponent <SceneComponent>();
sceneComponent.SceneSize = sceneDescriptor.sceneSize;
var environmentFolder = new GameObject(SceneDescriptorsHelper.EnvironmentFolderName).transform;
environmentFolder.transform.SetParent(scene);
SpritesCache cache = new SpritesCache();
SceneDescriptorsHelper.CreateInstances(sceneDescriptor.imagesEnvironment, environmentFolder, cache);
SceneDescriptorsHelper.CreateInstances(sceneDescriptor.items, scene, cache);
}
private void OnCreateButtonClick()
{
SceneItem[] AllItems = scene.GetComponentsInChildren <SceneItem>();
List <SceneItem> AllItemList = new List <SceneItem>(AllItems);
foreach (SceneItem item in AllItemList)
{
if (item.transform == scene)
{
continue;
}
Transform[] placeHolders = item.GetComponentsInChildren <Transform>();
int counter = placeHolders.Length + 1;
for (int i = 0; i < 10; i++)
{
foreach (Transform placeHolder in placeHolders)
{
if (placeHolder == item.transform || placeHolder.parent != item.transform)
{
continue;
}
GameObject newPlaceHolder = Instantiate(placeHolder.gameObject, item.transform) as GameObject;
newPlaceHolder.name = item.name + "_" + counter;
SpriteRenderer[] images = newPlaceHolder.GetComponentsInChildren <SpriteRenderer>();
foreach (SpriteRenderer image in images)
{
string resourceName = SceneDescriptorsHelper.GetResourceName(AssetDatabase.GetAssetPath(image.sprite)) + UnityEngine.Random.Range(2, 21);
Sprite[] spritesAll = Resources.LoadAll <Sprite>(resourceName);
Sprite sprite = spritesAll.FirstOrDefault(x => x.name == image.sprite.name);
image.sprite = sprite;
}
counter++;
}
}
}
for (int i = 0; i < 10; i++)
{
foreach (SceneItem item in AllItemList)
{
if (item.transform == scene)
{
continue;
}
GameObject newitem = Instantiate(item.gameObject, scene.transform) as GameObject;
newitem.name = item.name + i;
}
}
}
private List <ItemDescriptor> GetItems()
{
List <ItemDescriptor> itemList = new List <ItemDescriptor>();
SceneItem[] allItems = scene.GetComponentsInChildren <SceneItem>();
foreach (SceneItem item in allItems)
{
if (item == scene)
{
continue;
}
itemList.Add(SceneDescriptorsHelper.CreateItemDescriptor(item));
}
return(itemList);
}
public BuildResult Build(SceneDescriptor sceneDescriptor)
{
// in this case scene does not exists
// so first need to pick items directly from SceneDescriptor
// and then create objects ONLY for picked items
SpritesCache cache = new SpritesCache();
// create scene
Transform sceneFolder = CreateSceneFolder(sceneDescriptor);
// load envinronment images
SceneDescriptorsHelper.CreateInstances(sceneDescriptor.imagesEnvironment, sceneFolder, cache);
// load items from SceneDescriptor
var visibleItems = CreateVisibleItems(shuffle(sceneDescriptor.items).ToList(), sceneFolder, cache, _buildParams);
// and make some of them pickable
var pickableItems = MakeSomeSceneItemsPickable(visibleItems, _buildParams);
return(GetBuildResult(pickableItems));
}
private List <ImageDescriptor> GetImagesEnvironment()
{
List <ImageDescriptor> imagesList = new List <ImageDescriptor>();
foreach (Transform layer in scene)
{
if (layer.GetComponent <SceneItem>() != null || String.Compare(layer.name, SceneDescriptorsHelper.ErrorFolderName, true) == 0)
{
continue;
}
Transform[] allImages = layer.GetComponentsInChildren <Transform>();
foreach (Transform image in allImages)
{
if (image.GetComponent <SceneItem>() != null || image.GetComponent <SpriteRenderer>() == null)
{
continue;
}
imagesList.Add(SceneDescriptorsHelper.CreateImageDescriptor(image.GetComponent <SpriteRenderer>()));
}
}
return(imagesList);
}
public static ItemDescriptor CreateItemDescriptor(SceneItem item)
{
ItemDescriptor itemDescriptor = new ItemDescriptor();
itemDescriptor.name = item.gameObject.name;
if (string.IsNullOrEmpty(item.DisplayName.Trim()))
{
itemDescriptor.displayName = SceneDescriptorsHelper.ToDisplayName(item.gameObject.name);
}
else
{
itemDescriptor.displayName = item.DisplayName.Trim();
}
if (item.Silhouette != null)
{
itemDescriptor.displayImage = CreateImageDescriptor(item.Silhouette);
}
itemDescriptor.placeHolders = GetItemPlaceHolders(item);
return(itemDescriptor);
}
public Sprite Get(string assetPath, string spriteName)
{
string resourceName = SceneDescriptorsHelper.GetResourceName(assetPath);
if (StringHelper.IsNullOrWhitespace(resourceName) || StringHelper.IsNullOrWhitespace(spriteName))
{
return(null);
}
if (!dictionary.ContainsKey(resourceName))
{
Put(resourceName);
}
Sprite sprite = dictionary[resourceName].FirstOrDefault(x => x.name == spriteName);
if (sprite == null)
{
Debug.LogError("Error sprite in asset : " + spriteName + " does not exist!");
return(null);
}
return(sprite);
}
public BuildResult Build(TextAsset textAsset)
{
SceneDescriptor sceneDescriptor = SceneDescriptorsHelper.CreateFromString(textAsset.text);
return(Build(sceneDescriptor));
}
public BuildResult Build(string dataBasePath)
{
SceneDescriptor sceneDescriptor = SceneDescriptorsHelper.LoadFromFile(dataBasePath);
return(Build(sceneDescriptor));
}
private void AttachSceneItemComponents(Dictionary <string, Item> items)
{
if (items == null)
{
#if DEBUG_SCENE_GENERATION
Debug.LogError("AttachSceneItemComponents: Error: items is null");
#endif
return;
}
foreach (var item in items)
{
Transform sceneItem = null;
SceneItem sceneItemComponent = null;
foreach (var placeHolder in item.Value.placeHolders)
{
if (placeHolder.Value.itemImage == null)
{
foreach (var patch in placeHolder.Value.patches)
{
patch.gameObject.transform.SetParent(GetErrorFolder());
}
foreach (var shadow in placeHolder.Value.shadows)
{
shadow.gameObject.transform.SetParent(GetErrorFolder());
}
}
else
{
Transform parent = null;
if (sceneItem == null)
{
sceneItem = new GameObject(item.Key).transform;
sceneItem.SetParent(scene_folder);
sceneItemComponent = sceneItem.gameObject.AddComponent <SceneItem>();
sceneItemComponent.DisplayName = SceneDescriptorsHelper.ToDisplayName(item.Key);
if (item.Value.displayImage != null)
{
sceneItemComponent.Silhouette = item.Value.displayImage.sprite;
// destroy silhouette object
GameObject.DestroyImmediate(item.Value.displayImage.gameObject);
}
}
placeHolder.Value.itemImage.gameObject.transform.SetParent(sceneItem);
parent = placeHolder.Value.itemImage.gameObject.transform;
foreach (var patch in placeHolder.Value.patches)
{
var component = patch.gameObject.AddComponent <SceneItemChildLayer>();
component.Type = SceneItemChildLayer.LayerType.Patch;
if (sceneItemComponent)
{
sceneItemComponent.ChildLayers.Add(component);
}
patch.gameObject.transform.SetParent(parent);
}
foreach (var shadow in placeHolder.Value.shadows)
{
var component = shadow.gameObject.AddComponent <SceneItemChildLayer>();
component.Type = SceneItemChildLayer.LayerType.Shadow;
if (sceneItemComponent)
{
sceneItemComponent.ChildLayers.Add(component);
}
shadow.gameObject.transform.SetParent(parent);
}
}
}
}
}
