public PathStyle Register(PathType type, AssetManagerLoader loader, PathStyle style)
{
PathStyle path = Build(style);
_register(type, loader, path);
return(path);
}
public TResult Build(AssetManagerLoader loader)
{
GameObject go = UnityEngine.Object.Instantiate(_go);
TResult shop = go.GetComponent <TResult>();
if (shop == null)
{
shop = go.AddComponent <TResult>();
if (!ContainsTag("GUID"))
{
throw new Exception("GUID is never set");
}
}
Apply(new BaseObjectContainer <TResult>(loader, shop, go));
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
// register shop
loader.RegisterObject(shop);
return(shop);
}
public override TResult Build(AssetManagerLoader loader)
{
GameObject go = UnityEngine.Object.Instantiate(_go);
TResult trashBin = go.GetComponent <TResult>();
if (trashBin == null)
{
trashBin = go.AddComponent <TResult>();
if (!ContainsTag("GUID"))
{
throw new Exception("Guid is never set");
}
}
Apply(new BaseObjectContainer <TResult>(loader, trashBin, go));
// ApplyGroup(BasePathAttachmentLiteral.SetupGroup, dc);
// ApplyGroup(BasePathAttachmentLiteral.ConfigurationGroup, dc);
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
return(trashBin);
}
public BodyPartBuilder AddHeadProduct <TResult>(AssetManagerLoader loader, IBuildable <TResult> builder)
where TResult : WearableProduct
{
AddStep("HEAD_PRODUCT",
(handler) => { _appendFieldProductWearable(handler.Target, "headItems", builder.Build(loader)); });
return(this);
}
public TResult Build(AssetManagerLoader loader)
{
GameObject go = Object.Instantiate(_go);
TResult balloon = go.GetComponent <TResult>();
if (balloon == null)
{
Balloon cpy = (Balloon)AssetManager.Instance.getPrefab(Prefabs.BalloonRegular);
balloon = go.AddComponent <TResult>();
balloon.pokeSound = cpy.pokeSound;
balloon.popSound = cpy.popSound;
balloon.popParticlesGO = cpy.popParticlesGO;
}
if (balloon.transform.childCount == 0)
{
GameObject stringAttachment = new GameObject("String");
stringAttachment.transform.parent = balloon.transform;
LineRenderer renderer = stringAttachment.AddComponent <LineRenderer>();
renderer.positionCount = 2;
renderer.material = new Material(Shader.Find("Sprites/Default"));
}
Apply(new BaseObjectContainer <TResult>(loader, balloon, go));
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
loader.RegisterObject(balloon);
return(balloon);
}
public CostumeBuilder BodyPartFemale <TResult>(AssetManagerLoader loader,
IBuildable <BodyPartsContainer> container)
where TResult : BodyPartsContainer
{
AddStep("BODY_PART_FEMALE", handler => { handler.Target.bodyPartsFemale = container.Build(loader); });
return(this);
}
public BodyPartBuilder AddAccessoryProduct <TResult>(AssetManagerLoader loader,
IBuildable <TResult> builder)
where TResult : WearableProduct
{
AddStep("ACCESSORY_PRODUCT",
(handler) => { _appendFieldProductWearable(handler.Target, "accessories", builder.Build(loader)); });
return(this);
}
public EmployeeCostume Build(AssetManagerLoader loader)
{
var employeeCostume = ScriptableObject.CreateInstance <EmployeeCostume>();
employeeCostume.customColors = new Color[] { };
Apply(new BaseContainer <EmployeeCostume>(loader, employeeCostume));
loader.RegisterObject(employeeCostume);
return(employeeCostume);
}
public TSelf ClearIngredient(AssetManagerLoader loader)
{
RemoveAllStepsByTag("INGREDIENT");
AddStep("INGREDIENT", handler =>
{
handler.Target.ingredients = new Ingredient[] { };
});
return(this as TSelf);
}
public EmployeeCostume Register(AssetManagerLoader loader, Entertainer entertainer)
{
Array.Resize(ref entertainer.costumes, entertainer.costumes.Length + 1);
EmployeeCostume costume = Build(loader);
entertainer.costumes[entertainer.costumes.Length - 1] = costume;
String id = costume.name;
loader.AddUnregisterHandler(() =>
{
entertainer.costumes = entertainer.costumes.Where((source, index) => !source.name.Equals(id)).ToArray();
});
return(entertainer.costumes[entertainer.costumes.Length - 1]);
}
public ProductShopBuilder <TResult> AddProduct(AssetManagerLoader loader, Product product)
{
AddStep("PRODUCT", (payload) =>
{
if (payload.Target.products == null)
{
payload.Target.products = new[] { product };
}
else
{
Array.Resize(ref payload.Target.products, payload.Target.products.Length + 1);
payload.Target.products[payload.Target.products.Length - 1] = product;
}
});
return(this);
}
public ProductShopBuilder <TResult> AddProduct <TTarget>(AssetManagerLoader loader, IBuildable <TTarget> product)
where TTarget : Product
{
AddStep("PRODUCT", (payload) =>
{
if (payload.Target.products == null)
{
payload.Target.products = new[] { product.Build(loader) };
}
else
{
Array.Resize(ref payload.Target.products, payload.Target.products.Length + 1);
payload.Target.products[payload.Target.products.Length - 1] = product.Build(loader);
}
});
return(this);
}
public Trash Build(AssetManagerLoader loader)
{
GameObject go = UnityEngine.Object.Instantiate(_go);
TResult trash = go.GetComponent <TResult>();
if (trash == null)
{
trash = go.AddComponent <TResult>();
}
Apply(new BaseObjectContainer <TResult>(loader, trash, go));
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
loader.RegisterObject(trash);
return(trash);
}
public IngredientBuilder <TSelf> AddIngredient(AssetManagerLoader loader)
{
IngredientBuilder <TSelf> builder = new IngredientBuilder <TSelf>(this as TSelf);
AddStep("INGREDIENT", handler =>
{
if (handler.Target.ingredients == null)
{
handler.Target.ingredients = new[] { builder.Build(loader) };
}
else
{
Array.Resize(ref handler.Target.ingredients, handler.Target.ingredients.Length + 1);
handler.Target.ingredients[handler.Target.ingredients.Length - 1] = builder.Build(loader);
}
});
return(builder);
}
public Ingredient Build(AssetManagerLoader loader)
{
Ingredient result = new Ingredient();
var resource = ScriptableObject.CreateInstance <Resource>();
resource.name = _id;
resource.effects = _effects.ToArray();
resource.setDisplayName(_displayName);
resource.setCosts(_cost);
resource.resourceTexture = _texture;
result.resource = resource;
result.tweakable = _tweakable;
result.defaultAmount = _amount;
loader.RegisterObject(resource);
return(result);
}
public TResult Build(AssetManagerLoader loader)
{
GameObject go = Object.Instantiate(_go);
TResult product = go.GetComponent <TResult>();
if (product == null)
{
product = go.AddComponent <TResult>();
}
Apply(new BaseObjectContainer <TResult>(loader, product, go));
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
// register shop
loader.RegisterObject(product);
return(product);
}
public override TResult Build(AssetManagerLoader loader)
{
GameObject go = UnityEngine.Object.Instantiate(_go);
TResult pathAttachment = go.GetComponent <TResult>();
if (pathAttachment == null)
{
pathAttachment = go.AddComponent <TResult>();
if (!ContainsTag("GUID"))
{
throw new Exception("Guid is never set");
}
}
Apply(new BaseObjectContainer <TResult>(loader, pathAttachment, go));
foreach (Renderer componentsInChild in go.GetComponentsInChildren <Renderer>())
{
Parkitility.ReplaceWithParkitectMaterial(componentsInChild);
}
return(pathAttachment);
}
private void _register(PathType type, AssetManagerLoader loader, PathStyle path)
{
switch (type)
{
case PathType.Employee:
AssetManager.Instance.employeePathStyles.registerPathStyle(path);
loader.AddUnregisterHandler(() =>
{
AssetManager.Instance.employeePathStyles.unregisterPathStyle(path);
});
break;
case PathType.Normal:
AssetManager.Instance.pathStyles.registerPathStyle(path);
loader.AddUnregisterHandler(() => { AssetManager.Instance.pathStyles.unregisterPathStyle(path); });
break;
case PathType.Queue:
AssetManager.Instance.queueStyles.registerPathStyle(path);
loader.AddUnregisterHandler(() => { AssetManager.Instance.queueStyles.unregisterPathStyle(path); });
break;
}
}
public BodyPartsContainer Build(AssetManagerLoader loader)
{
if (_container == null)
{
_container = ScriptableObject.CreateInstance <BodyPartsContainer>();
typeof(BodyPartsContainer)
.GetField("torsos", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new GameObject[] {});
typeof(BodyPartsContainer)
.GetField("heads", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new GameObject[] {});
typeof(BodyPartsContainer)
.GetField("legs", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new GameObject[] {});
typeof(BodyPartsContainer)
.GetField("hairstyles", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new GameObject[] {});
typeof(BodyPartsContainer)
.GetField("accessories", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new WearableProduct[] { });
typeof(BodyPartsContainer)
.GetField("headItems", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new WearableProduct[] { });
typeof(BodyPartsContainer)
.GetField("faceItems", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic)
?.SetValue(_container, new WearableProduct[] { });
}
Apply(new BaseContainer <BodyPartsContainer>(loader, _container));
Debug.Log("HEADS:" + _container.getHeadsCount());
Debug.Log("HEADS:" + _container.getTorsosCount());
Debug.Log("HEADS:" + _container.getHairstylesCount());
return(_container);
}
public TResult Build(AssetManagerLoader loader)
{
throw new System.NotImplementedException();
}
public TrashBuilder <ConsumableProductBuilder <TResult>, TTrashResult> Trash <TTrashResult>(GameObject trashGo,
AssetManagerLoader loader) where TTrashResult : Trash
{
TrashBuilder <ConsumableProductBuilder <TResult>, TTrashResult> builder =
new TrashBuilder <ConsumableProductBuilder <TResult>, TTrashResult>(this, trashGo);
AddStep("TRASH", handler => { handler.Target.trash = builder.Build(loader); });
return(builder);
}
public abstract TResult Build(AssetManagerLoader loader);
