public void ServerInit()
{
if (isSoilPile)
{
//only select plants that have valid produce
plantData = PlantData.CreateNewPlant(DefaultPlantData.PlantDictionary.Values
.Where(plant => plant.plantData.ProduceObject != null).PickRandom());
UpdatePlant(null, plantData.Name);
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.FullyGrown);
UpdatePlantGrowthStage(growingPlantStage, plantData.GrowthSprites.Count - 1);
ProduceCrop();
}
else
{
plantData = null;
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.FullyGrown);
UpdatePlant(plantSyncString, null);
UpdatePlantGrowthStage(growingPlantStage, 0);
}
UpdateHarvestFlag(showHarvestFlag, false);
UpdateWeedsFlag(showWeedsFlag, false);
UpdateWaterFlag(showWaterFlag, false);
UpdateNutrimentFlag(showNutrimenetFlag, false);
}
/// <summary>
/// Handles processing produce into seed packets at rate defined by processingTime
/// </summary>
public override void UpdateMe()
{
//Only run on server and if there is something to process and the device has power
if (!isServer || !IsProcessing || currentState == PowerStates.Off)
{
return;
}
//If processing isn't done keep waiting
if (processingProgress < processingTime)
{
processingProgress += Time.deltaTime;
return;
}
//Handle completed processing
processingProgress = 0;
var grownFood = foodToBeProcessed.Dequeue();
var seedPacket = Spawn.ServerPrefab(grownFood.SeedPacket).GameObject.GetComponent <SeedPacket>();
seedPacket.plantData = PlantData.CreateNewPlant(grownFood.GetPlantData());
//Add seed packet to dispenser
seedPackets.Add(seedPacket);
updateEvent.Invoke();
//De-spawn processed food
Inventory.ServerDespawn(grownFood.gameObject);
if (foodToBeProcessed.Count == 0)
{
Chat.AddLocalMsgToChat("The seed extractor finishes processing", (Vector2Int)registerObject.WorldPosition, this.gameObject);
}
}
private void EnsureInit()
{
if (string.IsNullOrEmpty(plantData?.Name) && defaultPlantData != null)
{
plantData = PlantData.CreateNewPlant(defaultPlantData);
PlantSyncString = plantData.Name;
}
}
private void UpdatePlant(string oldPlantSyncString, string newPlantSyncString)
{
plantSyncString = newPlantSyncString;
if (newPlantSyncString == null)
{
plantData = null;
}
else if (DefaultPlantData.PlantDictionary.ContainsKey(plantSyncString))
{
plantData = PlantData.CreateNewPlant(DefaultPlantData.PlantDictionary[plantSyncString].plantData);
}
UpdateSprite();
}
/// <summary>
/// Gets seeds for plant and replaces held food with seeds
/// DOES NOT WORK, eating overrides this.
/// </summary>
/// <param name="interaction"></param>
public void ServerPerformInteraction(HandActivate interaction)
{
if (plantData != null)
{
var seedObject = Spawn.ServerPrefab(this.seedPacket, interaction.Performer.RegisterTile().WorldPositionServer, parent: interaction.Performer.transform.parent).GameObject;
var seedPacket = seedObject.GetComponent <SeedPacket>();
seedPacket.plantData = PlantData.CreateNewPlant(plantData);
seedPacket.SyncPlant(null, plantData.Name);
var slot = interaction.HandSlot;
Inventory.ServerAdd(seedObject, interaction.HandSlot, ReplacementStrategy.DespawnOther);
}
}
public void ServerInit()
{
if (isWild)
{
var data = potentialWildPlants[random.Next(potentialWildPlants.Count)];
plantData = PlantData.CreateNewPlant(data.plantData);
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.FullyGrown);
UpdatePlantGrowthStage(growingPlantStage, plantData.GrowthSpritesSOs.Count - 1);
ProduceCrop();
}
else
{
plantData = null;
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.FullyGrown);
UpdatePlantGrowthStage(growingPlantStage, 0);
}
UpdateHarvestFlag(showHarvestFlag, false);
UpdateWeedsFlag(showWeedsFlag, false);
UpdateWaterFlag(showWaterFlag, false);
UpdateNutrimentFlag(showNutrimenetFlag, false);
}
public void ServerPerformInteraction(HandApply interaction)
{
var slot = interaction.HandSlot;
//If hand slot contains mutagen, use 5 mutagen mutate plant
if (HasPlant)
{
if (plantData.MutatesInToGameObject.Count > 0)
{
var objectContainer = slot?.Item?.GetComponent <ReagentContainer>();
if (objectContainer != null)
{
objectContainer.MoveReagentsTo(5, reagentContainer);
Chat.AddActionMsgToChat(interaction.Performer,
$"You add reagents to the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} adds reagents to the {gameObject.ExpensiveName()}.");
if (reagentContainer[mutagen] >= 5)
{
reagentContainer.Subtract(new ReagentMix(mutagen, 5));
plantData.Mutation();
return;
}
}
}
}
var objectItemAttributes = slot?.Item?.GetComponent <ItemAttributesV2>();
if (objectItemAttributes != null)
{
//If hand slot contains Cultivator remove weeds
if (objectItemAttributes.HasTrait(CommonTraits.Instance.Cultivator))
{
if (weedLevel > 0)
{
Chat.AddActionMsgToChat(interaction.Performer,
$"You remove the weeds from the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} uproots the weeds.");
}
weedNotifier.PushClear();
weedLevel = 0;
return;
}
//If hand slot contains Bucket water plants
if (objectItemAttributes.HasTrait(CommonTraits.Instance.Bucket))
{
Chat.AddActionMsgToChat(interaction.Performer, $"You water the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} waters the {gameObject.ExpensiveName()}.");
reagentContainer.Add(new ReagentMix(water, 100));
return;
}
//If hand slot contains Trowel remove plants
if (objectItemAttributes.HasTrait(CommonTraits.Instance.Trowel))
{
if (HasPlant)
{
Chat.AddActionMsgToChat(interaction.Performer,
$"You dig out all of the {gameObject.ExpensiveName()}'s plants!",
$"{interaction.Performer.name} digs out the plants in the {gameObject.ExpensiveName()}!");
CropDeath();
}
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.None);
return;
}
}
//If hand slot contains grown food, plant the food
//This temporarily replaces the seed machine until it is implemented, see commented code for original compost behavior
var foodObject = slot?.Item?.GetComponent <GrownFood>();
if (foodObject != null)
{
if (HasPlant)
{
Chat.AddActionMsgToChat(interaction.Performer,
$"You compost the {foodObject.name} in the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} composts {foodObject.name} in the {gameObject.ExpensiveName()}.");
reagentContainer.Add(new ReagentMix(nutriment, foodObject.GetPlantData().Potency));
Despawn.ServerSingle(interaction.HandObject);
return;
}
else
{
PlantData _plantData = foodObject.GetPlantData();
plantData = PlantData.CreateNewPlant(_plantData);
UpdatePlantGrowthStage(0, 0);
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.Growing);
UpdateHarvestFlag(showHarvestFlag, false);
Inventory.ServerVanish(slot);
Chat.AddActionMsgToChat(interaction.Performer,
$"You plant the {foodObject.name} in the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} plants the {foodObject.name} in the {gameObject.ExpensiveName()}.");
}
}
//If hand slot contains seeds, plant the seeds
var Object = slot?.Item?.GetComponent <SeedPacket>();
if (Object != null)
{
plantData = PlantData.CreateNewPlant(slot.Item.GetComponent <SeedPacket>().plantData);
UpdatePlantGrowthStage(0, 0);
UpdatePlantStage(PlantSpriteStage.None, PlantSpriteStage.Growing);
UpdateHarvestFlag(showHarvestFlag, false);
Inventory.ServerVanish(slot);
Chat.AddActionMsgToChat(interaction.Performer,
$"You plant the {Object.name} in the {gameObject.ExpensiveName()}.",
$"{interaction.Performer.name} plants the {Object.name} in the {gameObject.ExpensiveName()}.");
return;
}
//If plant is ready to harvest then make produce visible and update plant state
if (plantData != null && ReadyToHarvest)
{
for (int i = 0; i < readyProduce.Count; i++)
{
CustomNetTransform netTransform = readyProduce[i].GetComponent <CustomNetTransform>();
netTransform.AppearAtPosition(registerTile.WorldPositionServer);
netTransform.AppearAtPositionServer(registerTile.WorldPositionServer);
}
readyProduce.Clear();
//If plant is Perennial then reset growth to the start of growing stage
if (plantData.PlantTrays.Contains(PlantTrays.Perennial_Growth))
{
plantData.NextGrowthStageProgress = 0;
UpdatePlantGrowthStage(growingPlantStage, 0);
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.Growing);
UpdateHarvestFlag(harvestNotifier, false);
}
//Else remove plant from tray
else
{
plantData = null;
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.None);
UpdateHarvestFlag(harvestNotifier, false);
}
}
//Commenting unless this causes issues
/*else
* {
* UpdatePlantStage(plantCurrentStage, PlantSpriteStage.None);
* }*/
}
/// <summary>
/// Server updates plant status and updates clients as needed
/// </summary>
public override void UpdateMe()
{
//Only server checks plant status, wild plants do not grow
if (!isServer || isWild)
{
return;
}
//Only update at set rate
tickCount += Time.deltaTime;
if (tickCount < tickRate)
{
return;
}
tickCount = 0f;
if (HasPlant)
{
//Up plants age
plantData.Age++;
//Weeds checks
if (weedLevel < 10)
{
weedLevel = weedLevel + ((0.1f) * (plantData.WeedGrowthRate / 10f));
if (weedLevel > 10)
{
weedLevel = 10;
}
}
if (weedLevel > 9.5f && !plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
plantData.Health += (((plantData.WeedResistance - 110f) / 100f) * (weedLevel / 10f) * 5);
//Logger.Log("plantData.weed > " + plantData.PlantHealth);
}
//Water Checks
if (reagentContainer[water] > 0)
{
reagentContainer.Subtract(new ReagentMix(water, .1f));
}
else if (!plantData.PlantTrays.Contains(PlantTrays.Fungal_Vitality))
{
plantData.Health += (plantData.Endurance - 101f) / 100f;
}
//Growth and harvest checks
if (!ReadyToHarvest)
{
plantData.NextGrowthStageProgress += (int)Math.Ceiling(plantData.GrowthSpeed / 5f);
if (plantData.NextGrowthStageProgress > 100)
{
plantData.NextGrowthStageProgress = 0;
if (reagentContainer[nutriment] > 0 || plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
if (!plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
if (reagentContainer[nutriment] > 0)
{
reagentContainer.Subtract(new ReagentMix(nutriment, 1));
}
}
if ((growingPlantStage + 1) < plantData.GrowthSpritesSOs.Count)
{
growingPlantStage = growingPlantStage + 1;
UpdateSprite();
plantCurrentStage = PlantSpriteStage.Growing;
}
else
{
if (!ReadyToHarvest)
{
//plantData.NaturalMutation(modification);
plantCurrentStage = PlantSpriteStage.FullyGrown;
ProduceCrop();
}
UpdateHarvestFlag(showHarvestFlag, true);
UpdateSprite();
}
}
else
{
plantData.Health += (((plantData.Endurance - 101f) / 100f) * 5);
//Logger.Log("plantData.Nutriment > " + plantData.PlantHealth);
}
}
}
//Health checks
if (plantData.Health < 0)
{
CropDeath();
}
else if (plantData.Age > plantData.Lifespan * 2500)
{
CropDeath();
}
}
//Empty tray checks
else
{
if (weedLevel < 10)
{
weedLevel += 0.01f;
if (weedLevel > 10)
{
weedLevel = 10;
}
}
// If there is no living plant in the tray and weed level is at least 10, choose a seed from the "Potential Weeds" list to grow in the tray.
if (plantData == null)
{
if (weedLevel >= 10)
{
var data = potentialWeeds[random.Next(potentialWeeds.Count)];
plantData = PlantData.CreateNewPlant(data.plantData);
growingPlantStage = 0;
plantCurrentStage = PlantSpriteStage.Growing;
weedLevel = 0;
//hasPlant = true;
UpdateSprite();
}
}
}
UpdateNutrimentFlag(showNutrimenetFlag, reagentContainer[nutriment] < 25);
UpdateWaterFlag(showWaterFlag, reagentContainer[water] < 25);
UpdateWeedsFlag(showWeedsFlag, weedLevel > 5);
}
/// <summary>
/// Server updates plant status and updates clients as needed
/// </summary>
public override void UpdateMe()
{
//Only server checks plant status, wild plants do not grow
if (!isServer || isWild)
{
return;
}
//Only update at set rate
tickCount += Time.deltaTime;
if (tickCount < tickRate)
{
return;
}
tickCount = 0f;
if (HasPlant)
{
//Up plants age
plantData.Age++;
//Weeds checks
if (weedLevel < 10)
{
weedLevel = weedLevel + ((0.1f) * (plantData.WeedGrowthRate / 100f));
if (weedLevel > 10)
{
weedLevel = 10;
}
}
if (weedLevel > 9.5f && !plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
plantData.Health += (((plantData.WeedResistance - 110f) / 100f) * (weedLevel / 10f) * 5);
//Logger.Log("plantData.weed > " + plantData.PlantHealth);
}
//Water Checks
if (reagentContainer.Contents.ContainsKey("water"))
{
if (reagentContainer.Contents["water"] > 0)
{
reagentContainer.Contents["water"] = reagentContainer.Contents["water"] - 0.1f;
}
else if (reagentContainer.Contents["water"] <= 0 &&
!plantData.PlantTrays.Contains(PlantTrays.Fungal_Vitality))
{
plantData.Health += (((plantData.Endurance - 101f) / 100f) * 1);
}
}
else if (!plantData.PlantTrays.Contains(PlantTrays.Fungal_Vitality))
{
plantData.Health += (((plantData.Endurance - 101f) / 100f) * 1);
}
//Growth and harvest checks
if (!ReadyToHarvest)
{
plantData.NextGrowthStageProgress += (int)Math.Round(plantData.GrowthSpeed / 10f);
if (plantData.NextGrowthStageProgress > 100)
{
plantData.NextGrowthStageProgress = 0;
if (nutritionLevel > 0 || plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
if (!plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
if (nutritionLevel != 0)
{
nutritionLevel = nutritionLevel - 1;
}
if (nutritionLevel < 0)
{
nutritionLevel = 0;
}
}
if ((growingPlantStage + 1) < plantData.GrowthSprites.Count)
{
UpdatePlantGrowthStage(growingPlantStage, growingPlantStage + 1);
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.Growing);
}
else
{
if (!ReadyToHarvest)
{
//plantData.NaturalMutation(modification);
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.FullyGrown);
ProduceCrop();
}
UpdateHarvestFlag(harvestNotifier, true);
}
}
else
{
plantData.Health += (((plantData.Endurance - 101f) / 100f) * 5);
//Logger.Log("plantData.Nutriment > " + plantData.PlantHealth);
}
}
}
//Health checks
if (plantData.Health < 0)
{
CropDeath();
}
else if (plantData.Age > plantData.Lifespan * 500)
{
CropDeath();
}
}
//Empty tray checks
else
{
if (weedLevel < 10)
{
weedLevel = weedLevel + ((0.1f) * (0.1f));
if (weedLevel > 10)
{
weedLevel = 10;
}
}
if (plantData != null)
{
if (weedLevel >= 10 && !plantData.PlantTrays.Contains(PlantTrays.Weed_Adaptation))
{
var data = potentialWeeds[random.Next(potentialWeeds.Count)];
plantData = PlantData.CreateNewPlant(data.plantData);
UpdatePlant(null, plantData.Name);
UpdatePlantGrowthStage(growingPlantStage, 0);
UpdatePlantStage(plantCurrentStage, PlantSpriteStage.Growing);
weedLevel = 0;
//hasPlant = true;
}
}
}
if (nutritionLevel < 25)
{
UpdateNutrimentFlag(showNutrimenetFlag, true);
}
else
{
UpdateNutrimentFlag(showNutrimenetFlag, false);
}
if (reagentContainer.Contents.ContainsKey("water"))
{
if (reagentContainer.Contents["water"] < 25)
{
UpdateWaterFlag(showWaterFlag, true);
}
else
{
UpdateWaterFlag(showWaterFlag, false);
}
}
else
{
UpdateWaterFlag(showWaterFlag, true);
}
if (weedLevel > 5)
{
UpdateWeedsFlag(showWeedsFlag, true);
}
else
{
UpdateWeedsFlag(showWeedsFlag, false);
}
}
public static void Generate()
{
float progressbarStep;
float progressbarState;
DirectoryInfo d = new DirectoryInfo(Application.dataPath + @"\Textures\objects\hydroponics\growing");
FileInfo[] Files = d.GetFiles("*.png"); // \\Getting Text files
var ListFiles = new List <string>();
dictonaryErrors = new Dictionary <string, string>();
var PlantDictionary = new Dictionary <string, DefaultPlantData>();
var PlantDictionaryObject = new Dictionary <string, System.Object>();
foreach (FileInfo file in Files)
{
ListFiles.Add(file.Name);
}
var food = (Resources.Load(@"Prefabs\Items\Botany\food") as GameObject);
var json = (Resources.Load(@"Metadata\plants") as TextAsset).ToString();
var plats = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(json);
progressbarStep = 1f / (plats.Count * ListFiles.Count);
progressbarState = 0;
foreach (var plat in plats)
{
EditorUtility.DisplayProgressBar("Step 1/3 Setting Sprites", "Loading plant: " + plat["name"], progressbarState);
//\\foreach (var Datapiece in plat)
//\\{
//\\ Logger.Log(Datapiece.Key);
//\\}
var plantdata = PlantData.CreateNewPlant((PlantData)null);
plantdata.ProduceObject = food;
plantdata.Name = plat["name"] as string;
if (plat.ContainsKey("plantname"))
{
plantdata.Plantname = plat["plantname"] as string;
}
plantdata.Description = plat["Description"] as string;
var species = "";
if (plat.ContainsKey("species"))
{
species = (plat["species"] as string);
}
else
{
Debug.Log($"Unable to find 'species' tag for plant {plantdata.Name}, using 'seed_packet' instead");
species = (plat["seed_packet"] as string);
if (species.Contains("seed-"))
{
species = species.Replace("seed-", "");
}
else if (species.Contains("mycelium-"))
{
species = species.Replace("mycelium-", "");
}
};
plantdata.PacketsSprite = new SpriteSheetAndData();
plantdata.PacketsSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\seeds\" + (plat["seed_packet"] as string) + ".png", typeof(Texture2D)) as Texture2D);
plantdata.PacketsSprite.setSprites();
SpriteSheetAndData produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + ".png", typeof(Texture2D)) as Texture2D);
if (produceSprite.Texture == null)
{
produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + "pile.png", typeof(Texture2D)) as Texture2D);
}
if (produceSprite.Texture == null)
{
produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + "_leaves.png", typeof(Texture2D)) as Texture2D);
}
if (produceSprite.Texture == null)
{
produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + "pod.png", typeof(Texture2D)) as Texture2D);
}
if (produceSprite.Texture == null)
{
produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + "s.png", typeof(Texture2D)) as Texture2D);
}
if (produceSprite.Texture == null)
{
produceSprite = new SpriteSheetAndData();
produceSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\harvest\" + species + "pepper.png", typeof(Texture2D)) as Texture2D);
}
produceSprite.setSprites();
var dead_sprite = (plat.ContainsKey("dead_Sprite")) ? (plat["dead_Sprite"] as string) : species + "-dead";
plantdata.DeadSprite = new SpriteSheetAndData();
plantdata.DeadSprite.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\growing\" + dead_sprite + ".png", typeof(Texture2D)) as Texture2D);
plantdata.DeadSprite.setSprites();
plantdata.GrowthSprites = new List <SpriteSheetAndData>();
foreach (var ListFile in ListFiles)
{
if (ListFile.Contains(species))
{
var Namecheck = ListFile;
/*Namecheck = Namecheck.Replace("growing_flowers_", "");
* Namecheck = Namecheck.Replace("growing_fruits_", "");
* Namecheck = Namecheck.Replace("growing_mushrooms_", "");
* Namecheck = Namecheck.Replace("growing_vegetables_", "");
* Namecheck = Namecheck.Replace("growing_", "");*/
Namecheck = Namecheck.Split('-')[0];
if (Namecheck == species)
{
EditorUtility.DisplayProgressBar("Step 1/3 Setting Sprites", $"Loading sprite '{ListFile}' for plant {plantdata.Name}", progressbarState);
if (!ListFile.Contains("-dead"))
{
if (!ListFile.Contains("-harvest"))
{
//\Assets\Resources\textures\objects\hydroponics\growing\growing_ambrosia_gaia-grow6.png
var _SpriteSheetAndData = new SpriteSheetAndData();
_SpriteSheetAndData.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\growing\" + ListFile, typeof(Texture2D)) as Texture2D);
_SpriteSheetAndData.setSprites();
plantdata.GrowthSprites.Add(_SpriteSheetAndData);
//If not found do at end
}
else
{
var _SpriteSheetAndData = new SpriteSheetAndData();
_SpriteSheetAndData.Texture = (AssetDatabase.LoadAssetAtPath(@"Assets\textures\objects\hydroponics\growing\" + ListFile, typeof(Texture2D)) as Texture2D);
_SpriteSheetAndData.setSprites();
plantdata.FullyGrownSprite = _SpriteSheetAndData;
}
}
}
}
if (plantdata.FullyGrownSprite == null)
{
if (plantdata.GrowthSprites.Count > 0)
{
//This seems to be normal
plantdata.FullyGrownSprite = plantdata.GrowthSprites[plantdata.GrowthSprites.Count - 1];
}
}
progressbarState += progressbarStep;
}
//check if sprites are missing
if (plantdata.PacketsSprite.Texture == null)
{
AppendError(plantdata.Name, $"Unable to find seed packet sprite for plant {plantdata.Name}");
}
//if (plantdata.ProduceSprite.Texture == null) { }
if (plantdata.DeadSprite.Texture == null)
{
AppendError(plantdata.Name, $"Unable to find dead sprite");
}
if (plantdata.GrowthSprites.Count == 0)
{
AppendError(plantdata.Name, $"Unable to find growth sprites for plant {plantdata.Name}");
}
if (plantdata.FullyGrownSprite == null)
{
AppendError(plantdata.Name, $"Unable to find fully grown sprite");
}
plantdata.WeedResistance = int.Parse(plat["weed_resistance"].ToString());
plantdata.WeedGrowthRate = int.Parse(plat["weed_growth_rate"].ToString());
plantdata.Potency = int.Parse(plat["potency"].ToString());
plantdata.Endurance = int.Parse(plat["endurance"].ToString());
plantdata.Yield = int.Parse(plat["plant_yield"].ToString());
plantdata.Lifespan = int.Parse(plat["lifespan"].ToString());
plantdata.GrowthSpeed = int.Parse(plat["production"].ToString());
if (plat.ContainsKey("genes"))
{
var genes = JsonConvert.DeserializeObject <List <string> >(plat["genes"].ToString());
foreach (var gene in genes)
{
if (gene == "Perennial_Growth")
{
plantdata.PlantTrays.Add(PlantTrays.Perennial_Growth);
}
else if (gene == "Fungal Vitality")
{
plantdata.PlantTrays.Add(PlantTrays.Fungal_Vitality);
}
else if (gene == "Liquid Contents")
{
plantdata.PlantTrays.Add(PlantTrays.Liquid_Content);
}
else if (gene == "Slippery Skin")
{
plantdata.PlantTrays.Add(PlantTrays.Slippery_Skin);
}
else if (gene == "Bluespace Activity")
{
plantdata.PlantTrays.Add(PlantTrays.Bluespace_Activity);
}
else if (gene == "Densified Chemicals")
{
plantdata.PlantTrays.Add(PlantTrays.Densified_Chemicals);
}
else if (gene == "Capacitive Cell Production")
{
plantdata.PlantTrays.Add(PlantTrays.Capacitive_Cell_Production);
}
else if (gene == "Weed Adaptation")
{
plantdata.PlantTrays.Add(PlantTrays.Weed_Adaptation);
}
else if (gene == "Hypodermic Prickles")
{
plantdata.PlantTrays.Add(PlantTrays.Hypodermic_Needles);
}
else if (gene == "Shadow Emission")
{
plantdata.PlantTrays.Add(PlantTrays.Shadow_Emission);
}
else if (gene == "Red Electrical Glow")
{
plantdata.PlantTrays.Add(PlantTrays.Red_Electrical_Glow);
}
else if (gene == "Electrical Activity")
{
plantdata.PlantTrays.Add(PlantTrays.Electrical_Activity);
}
else if (gene == "Strong Bioluminescence")
{
plantdata.PlantTrays.Add(PlantTrays.Strong_Bioluminescence);
}
else if (gene == "Bioluminescence")
{
plantdata.PlantTrays.Add(PlantTrays.Bioluminescence);
}
else if (gene == "Separated Chemicals")
{
plantdata.PlantTrays.Add(PlantTrays.Separated_Chemicals);
}
}
}
//Creating/updating food prefabs
if (plat.ContainsKey("produce_name"))
{
//load existing prefab variant if possible
GameObject prefabVariant = (GameObject)AssetDatabase.LoadAssetAtPath(@"Assets/Resources/Prefabs/Items/Botany/" + plantdata.Name + ".prefab", typeof(GameObject));
if (prefabVariant == null)
{
GameObject originalPrefab = (GameObject)AssetDatabase.LoadAssetAtPath(@"Assets/Resources/Prefabs/Items/Botany/food.prefab", typeof(GameObject));
prefabVariant = PrefabUtility.InstantiatePrefab(originalPrefab) as GameObject;
}
else
{
prefabVariant = PrefabUtility.InstantiatePrefab(prefabVariant) as GameObject;
}
var itemAttr = prefabVariant.GetComponent <ItemAttributesV2>();
//Commented since this are normally private
//itemAttr.initialName = plat["produce_name"] as string;
//itemAttr.initialDescription = plat["description"] as string;
//itemAttr.itemSprites = (new ItemsSprites() { InventoryIcon = produceSprite });
//add sprite to food
var spriteRenderer = prefabVariant.GetComponentInChildren <SpriteRenderer>();
spriteRenderer.sprite = SpriteFunctions.SetupSingleSprite(produceSprite).ReturnFirstSprite();
var newFood = prefabVariant.GetComponent <GrownFood>();
//Set plant data for food
newFood.plantData = plantdata;
var newReagents = prefabVariant.GetComponent <ReagentContainer>();
//add reagents to food
if (plat.ContainsKey("reagents_add"))
{
var Chemicals = JsonConvert.DeserializeObject <Dictionary <string, float> >(plat["reagents_add"].ToString());
var reagents = new List <string>();
var amounts = new List <float>();
foreach (var Chemical in Chemicals)
{
//ChemicalDictionary[Chemical.Key] = (((int)(Chemical.Value * 100)) * (plantdata.Potency / 100f));
reagents.Add(Chemical.Key);
amounts.Add(((int)(Chemical.Value * 100)) * (plantdata.Potency / 100f));
}
//newReagents.Reagents = reagents;
//newReagents.Amounts = amounts;
}
plantdata.ProduceObject = PrefabUtility.SaveAsPrefabAsset(prefabVariant, @"Assets/Resources/Prefabs/Items/Botany/" + plantdata.Name + ".prefab");
}
else
{
plantdata.ProduceObject = null;
}
var DefaultPlantData = ScriptableObject.CreateInstance <DefaultPlantData>();
DefaultPlantData.plantData = plantdata;
//\\ Creates the folder path
//\\ Creates the file in the folder path
Logger.Log(plantdata.Name + " < PlantDictionary");
PlantDictionary[plantdata.Name] = DefaultPlantData;
if (plat.ContainsKey("mutates_into"))
{
PlantDictionaryObject[plantdata.Name] = plat["mutates_into"];
}
//\\Logger.Log(plantdata.GrowthSprites.Count.ToString());
}
progressbarStep = 1f / PlantDictionary.Count;
progressbarState = 0;
var mutationNameList = new List <string>();
foreach (var pant in PlantDictionary)
{
EditorUtility.DisplayProgressBar("Step 2/3 Setting Mutations", "Loading mutations for: " + pant.Value.plantData.Name, progressbarState += progressbarStep);
if (PlantDictionaryObject.ContainsKey(pant.Value.plantData.Name))
{
var Mutations = JsonConvert.DeserializeObject <List <string> >(PlantDictionaryObject[pant.Value.plantData.Name].ToString());
foreach (var Mutation in Mutations)
{
if (!mutationNameList.Contains(Mutation))
{
mutationNameList.Add(Mutation);
}
if (Mutation.Length != 0)
{
if (PlantDictionary.ContainsKey(Mutation))
{
MutationComparison(pant.Value, PlantDictionary[Mutation]);
pant.Value.plantData.MutatesInTo.Add((DefaultPlantData)AssetDatabase.LoadAssetAtPath(@"Assets\Resources\ScriptableObjects\Plant default\" + PlantDictionary[Mutation].plantData.Name + ".asset", typeof(DefaultPlantData)));
if (PlantDictionary[Mutation].plantData.DeadSprite?.Texture == null)
{
if (pant.Value.plantData.DeadSprite?.Texture != null)
{
PlantDictionary[Mutation].plantData.DeadSprite = new SpriteSheetAndData();
PlantDictionary[Mutation].plantData.DeadSprite.Texture = pant.Value.plantData.DeadSprite.Texture;
PlantDictionary[Mutation].plantData.DeadSprite.setSprites();
}
}
if (PlantDictionary[Mutation].plantData.GrowthSprites.Count == 0)
{
PlantDictionary[Mutation].plantData.GrowthSprites = pant.Value.plantData.GrowthSprites;
}
}
}
}
}
}
progressbarStep = 1f / PlantDictionary.Count;
progressbarState = 0;
foreach (var pant in PlantDictionary)
{
DefaultPlantData defaultPlant = AssetDatabase.LoadMainAssetAtPath(@"Assets\Resources\ScriptableObjects\Plant default\" + pant.Value.plantData.Name + ".asset") as DefaultPlantData;
if (defaultPlant != null)
{
EditorUtility.DisplayProgressBar("Step 3/3 Saving ScriptObjects", "Updating asset: " + pant.Value.plantData.Name, progressbarState += progressbarStep);
EditorUtility.CopySerialized(pant.Value, defaultPlant);
AssetDatabase.SaveAssets();
}
else
{
EditorUtility.DisplayProgressBar("Step 3/3 Saving ScriptObjects", "Creating asset: " + pant.Value.plantData.Name, progressbarState += progressbarStep);
defaultPlant = ScriptableObject.CreateInstance <DefaultPlantData>();
EditorUtility.CopySerialized(pant.Value, defaultPlant);
AssetDatabase.CreateAsset(pant.Value, @"Assets\Resources\ScriptableObjects\Plant default\" + pant.Value.plantData.Name + ".asset");
}
if (dictonaryErrors.ContainsKey(pant.Value.plantData.Name))
{
if (mutationNameList.Contains(pant.Value.plantData.Name))
{
dictonaryErrors[pant.Value.plantData.Name] = $"Mutation {pant.Value.plantData.Name} has some missing sprites\n{dictonaryErrors[pant.Value.plantData.Name]}";
Debug.LogWarning(dictonaryErrors[pant.Value.plantData.Name]);
}
else
{
dictonaryErrors[pant.Value.plantData.Name] = $"Plant {pant.Value.plantData.Name} has some missing sprites\n{dictonaryErrors[pant.Value.plantData.Name]}";
Debug.LogError(dictonaryErrors[pant.Value.plantData.Name]);
}
}
}
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("Complete", "Generating default plant ScriptObjects complete", "Close");
}