internal static bool InitializeMiniAsEffect(CreatureBoardAsset creatureAsset, string effectName = null, string newCreatureName = null)
{
//Log.Indent($"InitializeMiniAsEffect({creatureAsset.CreatureId}, \"{effectName}\", \"{newCreatureName}\")");
try
{
if (effectName == null)
{
effectName = "R1.WaterWallSegment1";
}
IOldPersistentEffect persistentEffect = creatureAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"Error - persistentEffect == null (not found by call to GetPersistentEffect() on \"{creatureAsset.GetOnlyCreatureName()}\").");
persistentEffect = new SuperPersistentEffect();
if (persistentEffect is SuperPersistentEffect superPersistentEffect)
{
superPersistentEffect.EffectProperties.Add(new EffectProperties()
{
EffectName = effectName
});
}
}
return(InitializeMiniFromPersistentEffect(creatureAsset, persistentEffect, newCreatureName));
}
finally
{
//Log.Unindent();
}
}
public SavedCreatureEffect(CreatureGuid creatureId, IOldPersistentEffect persistentEffect, string newCreatureName)
{
NewCreatureName = newCreatureName;
ID = creatureId;
PersistentEffect = persistentEffect;
CreationTime = DateTime.Now;
}
public void Set(CreatureBoardAsset creatureAsset, GameObject assetLoader, GameObject effectOrb, GameObject attachedNode, IOldPersistentEffect persistentEffect)
{
CreatureAsset = creatureAsset;
AssetLoader = assetLoader;
EffectOrb = effectOrb;
AttachedNode = attachedNode;
PersistentEffect = persistentEffect;
}
public static void Duplicate(IOldPersistentEffect persistentEffect, string originalName)
{
//Log.Warning($"Duplicating (originalName = \"{originalName}\")...");
persistentEffect.Hidden = false;
string newName = IncrementEndingNumber(originalName);
Log.Warning($"Duplicate - newName = \"{newName}\"");
effectsToInitialize.Add(new QueuedEffect(InstantiateGoatAtPointer(), persistentEffect, newName));
}
private static void InitializeFromPersistentEffect(string creatureId, IOldPersistentEffect persistentEffect, string newCreatureName)
{
CreaturePresenter.TryGetAsset(new CreatureGuid(creatureId), out CreatureBoardAsset creatureAsset);
if (creatureAsset != null)
{
PersistentEffects.InitializeMiniFromPersistentEffect(creatureAsset, persistentEffect, newCreatureName);
}
else
{
Log.Warning($"creatureAsset is null (ID = {creatureId}) this update cycle....");
}
}
static void StorePersistentData(CreatureGuid iD, IOldPersistentEffect persistentEffect)
{
Log.Indent();
CreatureBoardAsset creatureBoardAsset = Minis.GetCreatureBoardAsset(iD.ToString());
if (creatureBoardAsset != null)
{
SavePersistentEffect(creatureBoardAsset, persistentEffect);
}
else
{
Log.Error($"StorePersistentData -- creatureBoardAsset is null!");
}
Log.Unindent();
}
private static void AttachEffects(CreatureBoardAsset creatureAsset, IOldPersistentEffect persistentEffect)
{
Log.Indent();
if (persistentEffect != null)
{
if (persistentEffect is SuperPersistentEffect superPersistentEffect)
{
for (int i = 0; i < superPersistentEffect.EffectProperties.Count; i++)
{
string prefix = i.ToString().PadLeft(2, '0');
EffectProperties effectProperties = superPersistentEffect.EffectProperties[i];
Log.Warning($"Adding effect {prefix} - \"{effectProperties.EffectName}\"");
GameObject spell = Spells.AttachEffect(creatureAsset, effectProperties.EffectName, creatureAsset.CreatureId.ToString(), 0, 0, 0, STR_AttachedNode, prefix);
TransferPropertiesToPersistentEffect(CompositeEffect.GetFromGameObject(spell), superPersistentEffect);
if (superPersistentEffect.ScriptData != null && superPersistentEffect.ScriptData.Count > 0)
{
Log.Debug($"");
foreach (string scriptName in superPersistentEffect.ScriptData.Keys)
{
Log.Warning($"Adding Script: {scriptName} to \"{creatureAsset.GetOnlyCreatureName()}\" with data: \"{superPersistentEffect.ScriptData[scriptName]}\"");
TaleSpireBehavior script = spell.AddComponent(KnownScripts.GetType(scriptName)) as TaleSpireBehavior;
if (script != null)
{
script.OwnerCreated(creatureAsset.CreatureId.ToString());
script.Initialize(superPersistentEffect.ScriptData[scriptName]);
}
}
}
}
}
else
{
Spells.AttachEffect(creatureAsset, persistentEffect.EffectName, creatureAsset.CreatureId.ToString(), 0, 0, 0, STR_AttachedNode);
}
}
else
{
Log.Error($"Unable to attach any effects. {nameof(persistentEffect)} is null!");
//Log.Warning($"Adding \"{defaultNewEffect}\"...");
//Spells.AttachEffect(creatureAsset, defaultNewEffect, creatureAsset.CreatureId.ToString(), 0, 0, 0, STR_AttachedNode);
}
Log.Unindent();
}
static void DuplicateEffectAtMenu(MapMenuItem menuItem, object arg2)
{
//if (menuItem != null)
// Talespire.Log.Warning($"menuItem.gameObject.name = {menuItem.gameObject.name}");
CreatureBoardAsset creatureAtMenu = RadialUI.RadialUIPlugin.CreatureAtMenu;
//Talespire.Log.Warning($"DuplicateEffectAtMenu: \"{menuItem}\", \"{arg2}\"");
//Talespire.Log.Warning($"CreatureAtMenu: {creatureAtMenu.Creature.Name}");
if (creatureAtMenu != null)
{
IOldPersistentEffect persistentEffect = creatureAtMenu.GetPersistentEffect();
//string persistentEffectData = creatureAtMenu.GetPersistentEffectData();
Talespire.PersistentEffects.Duplicate(persistentEffect, creatureAtMenu.GetOnlyCreatureName());
}
}
public static bool IsHidden(string creatureId)
{
CreatureBoardAsset creatureBoardAsset = Minis.GetCreatureBoardAsset(creatureId);
if (creatureBoardAsset == null)
{
Log.Error($"IsHidden -- creatureBoardAsset == null");
return(false);
}
IOldPersistentEffect persistentEffect = creatureBoardAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"IsHidden -- persistentEffect == null");
return(false);
}
return(persistentEffect.Hidden);
}
private static void AttachEffect(CreatureBoardAsset creatureAsset, IOldPersistentEffect persistentEffect, string newCreatureName)
{
if (persistentEffect == null)
{
Log.Error($"AttachEffect - persistentEffect is null!!!");
return;
}
if (creatureAsset == null)
{
Log.Error($"AttachEffect - creatureAsset is null!");
return;
}
if (!creatureAsset.HasAttachedData(STR_PersistentEffect))
{
savedEffectsData.Add(new SavedCreatureEffect(creatureAsset.CreatureId, persistentEffect, newCreatureName));
}
AttachEffects(creatureAsset, persistentEffect);
}
public static void SetHidden(CreatureBoardAsset creatureBoardAsset, bool hidden)
{
//Log.Debug($"SetHidden - hidden: {hidden}");
IOldPersistentEffect persistentEffect = creatureBoardAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"persistentEffect == null");
return;
}
persistentEffect.Hidden = hidden;
CreatureManager.SetCreatureExplicitHideState(creatureBoardAsset.Creature.CreatureId, hidden);
// Hide or show adornments:
GameObject effectOrb = GetEffectOrb(creatureBoardAsset);
foreach (string key in persistentEffect.Indicators.Keys)
{
bool indicatorVisible = persistentEffect.Indicators[key];
bool shouldBeVisible = !hidden && indicatorVisible;
SetOrbIndicatorVisible(effectOrb, shouldBeVisible, key);
}
if (persistentEffect is SuperPersistentEffect superPersistentEffect && superPersistentEffect.VisibilityMatchesBase)
{
GameObject attachedParentGameObject = creatureBoardAsset.GetAttachedParentGameObject();
if (attachedParentGameObject != null)
{
attachedParentGameObject.SetActive(!hidden);
}
else
{
Log.Error($"Unable to find attached parent game object! Cannot hide this control!");
}
}
creatureBoardAsset.SavePersistentEffect(persistentEffect);
}
public static void SetRotationLocked(CreatureBoardAsset creatureBoardAsset, bool locked)
{
//Log.Debug($"SetRotationLocked - locked: {locked}");
IOldPersistentEffect persistentEffect = creatureBoardAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"persistentEffect == null");
return;
}
//Log.Debug($"SetRotationLocked - IsVisible: {creatureBoardAsset.IsVisible}");
SetSpinLockVisible(creatureBoardAsset, locked && creatureBoardAsset.IsVisible);
persistentEffect.RotationIsLocked = locked;
if (locked)
{
persistentEffect.LockedRotation = creatureBoardAsset.GetRotationDegrees();
}
creatureBoardAsset.SavePersistentEffect(persistentEffect);
}
public static bool IsRotationLocked(string creatureId)
{
CreatureBoardAsset creatureBoardAsset = Minis.GetCreatureBoardAsset(creatureId);
if (creatureBoardAsset == null)
{
Log.Error($"IsRotationLocked -- creatureBoardAsset == null");
return(false);
}
IOldPersistentEffect persistentEffect = creatureBoardAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"IsRotationLocked -- persistentEffect == null");
return(false);
}
//Log.Debug($"persistentEffect.RotationLocked = {persistentEffect.RotationIsLocked}");
return(persistentEffect.RotationIsLocked);
}
public QueuedEffect(string id, IOldPersistentEffect persistentEffect, string miniName)
{
MiniName = miniName;
Id = id;
PersistentEffect = persistentEffect;
}
private static void InitializeNewlyCreatedPersistentEffect(CreatureBoardAsset creatureAsset, IOldPersistentEffect persistentEffect, string newCreatureName)
{
Log.Indent();
GameObject assetLoader = creatureAsset.GetAssetLoader();
if (assetLoader != null)
{
GameObject effectOrb = InitializeOrb(assetLoader);
GameObject attachedNode = AddAttachmentNode(assetLoader);
AttachEffect(creatureAsset, persistentEffect, newCreatureName);
persistentEffectEventArgs.Set(creatureAsset, assetLoader, effectOrb, attachedNode, persistentEffect);
OnPersistentEffectInitialized(creatureAsset, persistentEffectEventArgs);
}
Log.Unindent();
}
// TODO: Refactor this. Hard to read.
internal static bool InitializeMiniFromPersistentEffect(CreatureBoardAsset creatureAsset, IOldPersistentEffect persistentEffect, string newCreatureName)
{
//Log.Indent();
try
{
GameObject assetLoader = creatureAsset.GetAssetLoader();
//Log.Warning($"creatureAsset.Creature.Name = \"{creatureAsset.Creature.Name}\"");
if (assetLoader != null)
{
GameObject goatClone = assetLoader.FindChild(STR_UninitializedMiniMeshName);
if (goatClone != null)
{
MeshFilter meshFilter = goatClone.GetComponent <MeshFilter>();
MeshRenderer meshRenderer = goatClone.GetComponent <MeshRenderer>();
if (meshFilter != null && meshRenderer != null)
{
PositionOrb(goatClone);
ReplaceMaterial(meshFilter, meshRenderer);
if (persistentEffect == null)
{
persistentEffect = creatureAsset.GetPersistentEffect();
if (persistentEffect == null)
{
Log.Error($"persistentEffect is null! Creating Waterfall!");
persistentEffect = new OldPersistentEffect()
{
EffectName = "R1.WaterWallSegment1"
};
}
}
InitializeNewlyCreatedPersistentEffect(creatureAsset, persistentEffect, newCreatureName);
updatedCreatures.Add(creatureAsset.CreatureId.ToString());
Log.Debug($"returning true");
return(true);
}
else
{
Log.Debug($"Mesh Filter or Mesh Renderer not found in this update cycle...");
}
}
else
{
if (assetLoader.FindChild(STR_EffectOrb) != null)
{
//if (effectsToInitialize.Count > 0)
// Log.Warning($"effectsToInitialize.Count = {effectsToInitialize.Count}");
//if (updatedCreatures.Count > 0)
// Log.Warning($"updatedCreatures.Count = {updatedCreatures.Count}");
//Log.Warning($"Already initialized. Adding {creatureAsset.CreatureId.ToString()} to updatedCreatures");
persistentEffect = creatureAsset.GetPersistentEffect();
GameObject effectOrb = GetEffectOrb(creatureAsset);
GameObject attachedNode = creatureAsset.GetAttachedParentGameObject();
if (attachedNode != null)
{
persistentEffectEventArgs.Set(creatureAsset, assetLoader, effectOrb, attachedNode, persistentEffect);
OnPersistentEffectInitialized(creatureAsset, persistentEffectEventArgs);
}
else
{
Log.Error($"attachedNode is null!!!");
}
updatedCreatures.Add(creatureAsset.CreatureId.ToString());
}
else
{
Log.Debug($"goatClone not found in this update cycle...");
}
}
}
else
{
Log.Debug($"Asset Loader not found in this update cycle...");
}
//Log.Debug($"returning false");
return(false);
}
finally
{
//Log.Unindent();
}
}
private static void SavePersistentEffect(CreatureBoardAsset creatureAsset, IOldPersistentEffect persistentEffect)
{
Log.Indent();
string defaultNewEffect = JsonConvert.SerializeObject(persistentEffect);
if (!creatureAsset.HasAttachedData(STR_PersistentEffect))
{
Log.Warning($"SavePersistentEffect -- StatMessaging.SetInfo({creatureAsset.CreatureId}, {defaultNewEffect})");
StatMessaging.SetInfo(creatureAsset.CreatureId, STR_PersistentEffect, defaultNewEffect);
}
else
{
Log.Warning($" Attached data = \"{creatureAsset.GetAttachedData()[STR_PersistentEffect]}\"");
}
Log.Unindent();
}
private void UpdateInstance(IValueEditor editor, object valueOverride, bool committedChange)
{
if (lstProperties.SelectedItem is EffectProperty effectProperty)
{
// Store this change in the Mini.
if (frmPersistentEffectPropertyEditor != null)
{
Control childAtPoint = frmPersistentEffectPropertyEditor.GetChildAtPoint(new Point(4, 4));
if (childAtPoint is IValueEditor valueEditor)
{
BasePropertyChanger propertyChanger = valueEditor.GetPropertyChanger();
string saveValue = propertyChanger.Value;
if (propertyChanger != null)
{
string[] paths = effectProperty.Paths.Split(';');
bool needToSave = true;
foreach (string path in paths)
{
propertyChanger.FullPropertyPath = path;
propertyChanger.ValueOverride = valueOverride;
propertyChanger.ModifyProperty(Instance);
if (needToSave)
{
if (committedChange)
{
needToSave = false;
IOldPersistentEffect persistentEffect = Mini.GetPersistentEffect();
if (editor is IScriptEditor scriptEditor)
{
//Talespire.Log.Debug($"");
//Talespire.Log.Warning($"editor is IScriptEditor scriptEditor!!!");
//Talespire.Log.Warning($"effectProperty.Type = {effectProperty.Type?.FullName}");
//Talespire.Log.Warning($"scriptEditor.LastSerializedData = \"{scriptEditor.LastSerializedData}\"");
//Talespire.Log.Debug($"");
if (persistentEffect is SuperPersistentEffect superPersistentEffect)
{
if (effectProperty.Type != null)
{
superPersistentEffect.ScriptData[effectProperty.Type.FullName] = scriptEditor.LastSerializedData;
Mini.SavePersistentEffect(persistentEffect);
}
}
}
else
{
string propertyKey;
if (effectProperty.Name.StartsWith("$"))
{
propertyKey = effectProperty.Name;
}
else
{
propertyKey = effectProperty.Paths;
}
if (persistentEffect != null)
{
Talespire.Log.Warning($"Properties[{propertyKey}] = \"{saveValue}\"!!!");
// TODO: Use the correct EffectProperties instead of Properties (based on the prefix of the selected control).
// TODO: Change this to be indexed by the property NAME, not the path (to support multiple linked properties (to a single SmartProperty).
persistentEffect.Properties[propertyKey] = saveValue; // valueOverride.ToString();
Talespire.Log.Debug($"Mini.SavePersistentEffect();");
Mini.SavePersistentEffect(persistentEffect);
}
else
{
Talespire.Log.Error($"persistentEffect is not found!!");
}
}
}
else
{
//Talespire.Log.Warning($"Not a committed change! Not saving my friend!");
}
}
}
}
else
{
Talespire.Log.Error($"propertyChanger not found!!!");
}
}
else
{
Talespire.Log.Error($"childAtPoint is not a value editor!");
}
}
else
{
Talespire.Log.Error($"frmPersistentEffectPropertyEditor is null!");
}
}
else
{
Talespire.Log.Error($"effectProperty is NULL!!!");
}
}
