public void Initialize(CreatureBoardAsset creatureBoardAsset)
{
if (RotationIsLocked)
{
creatureBoardAsset.SetRotationDegrees(LockedRotation);
}
}
static CreatureBoardAsset AddTargetToNearestCreature()
{
CreatureBoardAsset creatureBoardAsset = GetNearestCreature();
AddTargetTo(creatureBoardAsset);
return(creatureBoardAsset);
}
/// <summary>
/// Returns a list of MemberLocations, sorted by distance to the specified leader.
/// </summary>
private List <MemberLocation> GetMemberLocations(CreatureBoardAsset leaderAsset)
{
if (lastMemberLocations != null)
{
return(lastMemberLocations);
}
List <MemberLocation> memberLocations = new List <MemberLocation>();
foreach (string memberId in Data.Members)
{
MemberLocation memberLocation = new MemberLocation();
CreatureBoardAsset creatureBoardAsset = Talespire.Minis.GetCreatureBoardAsset(memberId);
if (creatureBoardAsset == null)
{
continue;
}
memberLocation.Asset = creatureBoardAsset;
memberLocation.Name = creatureBoardAsset.GetOnlyCreatureName();
memberLocation.Position = creatureBoardAsset.PlacedPosition;
memberLocation.DistanceToLeader = (leaderAsset.PlacedPosition - creatureBoardAsset.PlacedPosition).magnitude;
memberLocations.Add(memberLocation);
}
memberLocations = memberLocations.OrderBy(x => x.DistanceToLeader).ToList();
return(memberLocations);
}
public static CreatureBoardAsset GetClosest(this CreatureBoardAsset asset, List <CreatureBoardAsset> assets)
{
if (assets == null || asset == null)
{
return(null);
}
float minDistanceSoFar = float.MaxValue;
CreatureBoardAsset result = null;
foreach (CreatureBoardAsset creature in assets)
{
if (creature == asset)
{
continue;
}
float distanceToCreature = (creature.PlacedPosition - asset.PlacedPosition).magnitude;
if (distanceToCreature < minDistanceSoFar)
{
result = creature;
minDistanceSoFar = distanceToCreature;
}
}
return(result);
}
public static CreatureBoardAsset GetCreatureClosestTo(Vector3 position, int maxRadiusFt)
{
CreatureBoardAsset closestCreature = null;
float shortestDistanceSoFar = float.MaxValue;
CreatureBoardAsset[] allCreatureAssets = GetAll();
if (allCreatureAssets == null)
{
return(null);
}
foreach (CreatureBoardAsset creatureBoardAsset in allCreatureAssets)
{
float distanceFeet = GetDistanceInFeet(position, creatureBoardAsset);
if (distanceFeet < shortestDistanceSoFar)
{
shortestDistanceSoFar = distanceFeet;
closestCreature = creatureBoardAsset;
}
}
if (shortestDistanceSoFar > maxRadiusFt)
{
return(null);
}
return(closestCreature);
}
private static void BoardToolManager_OnSwitchTool(BoardTool obj)
{
if (obj is CreatureMoveBoardTool)
{
CreatureBoardAsset selectedCreature = Minis.GetSelected();
draggingPersistentEffect = selectedCreature.GetPersistentEffect();
if (draggingPersistentEffect != null && draggingPersistentEffect.RotationIsLocked)
{
trackingDraggedMiniForRotationLock = true;
}
}
else
{
if (draggingPersistentEffect != null && trackingDraggedMiniForRotationLock)
{
CreatureBoardAsset selectedCreature = Minis.GetSelected();
if (selectedCreature != null)
{
selectedCreature.SetRotationDegrees(draggingPersistentEffect.LockedRotation);
}
}
draggingPersistentEffect = null;
trackingDraggedMiniForRotationLock = false;
}
}
public void RotateFormation(float degrees)
{
if (Guard.IsNull(memberLocationsBeforeRotation, "memberLocationsBeforeRotation"))
{
return;
}
// TODO: This 180 may be needed because of "centerPoint - memberLocation.Position", below. Reverse this and we may be able to remove the 180.
float degreesToRotate = degrees - degreesOffsetForRotation + 180;
CreatureBoardAsset leaderAsset = OwnerCreature;
if (Guard.IsNull(leaderAsset, "leaderAsset"))
{
return;
}
Vector3 centerPoint = leaderAsset.PlacedPosition;
foreach (MemberLocation memberLocation in memberLocationsBeforeRotation)
{
Vector3 offset = centerPoint - memberLocation.Position;
Vector3 newOffset = Quaternion.Euler(0, degreesToRotate, 0) * offset; // rotate it
Vector3 newPosition = centerPoint + newOffset; // calculate rotated point
Vector3 delta = newPosition - memberLocation.Asset.PlacedPosition;
Talespire.Minis.MoveRelative(memberLocation.Asset.CreatureId.ToString(), delta);
}
}
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 static int GetBaseColorIndex(this CreatureBoardAsset creatureBoardAsset)
{
if (Guard.IsNull(creatureBoardAsset, "creatureBoardAsset"))
{
return(0);
}
MaterialPropertyBlock _matBlock = ReflectionHelper.GetNonPublicField <MaterialPropertyBlock>(creatureBoardAsset, "_matBlock");
int BaseIndex = Shader.PropertyToID("_baseIndex");
if (_matBlock == null)
{
return(0);
}
Renderer[] renderers = creatureBoardAsset.Renderers;
if (renderers == null)
{
return(0);
}
if (renderers.Length <= 0 || renderers[0] == null)
{
return(0);
}
renderers[0].GetPropertyBlock(_matBlock);
return(_matBlock.GetInt(BaseIndex));
}
void RefreshMemberList()
{
Talespire.Log.Indent();
lstMembers.Items.Clear();
if (Guard.IsNull(MiniGrouperScript, "Script"))
{
return;
}
List <string> notFoundCreatures = new List <string>();
foreach (string member in MiniGrouperScript.Data.Members)
{
CreatureBoardAsset creatureBoardAsset = Talespire.Minis.GetCreatureBoardAsset(member);
if (creatureBoardAsset != null)
{
lstMembers.Items.Add(new GroupMember(creatureBoardAsset));
}
else
{
notFoundCreatures.Add(member);
}
}
MiniGrouperScript.RemoveMembers(notFoundCreatures);
Talespire.Log.Unindent();
}
public static CreatureStat GetStats(string id, int statIndex = -1)
{
CreatureBoardAsset asset = GetCreatureBoardAsset(id);
if (Guard.IsNull(asset, "asset"))
{
return(default);
void UpdateFlyingState()
{
Talespire.Log.Indent();
try
{
CreatureBoardAsset owner = OwnerCreature;
if (Guard.IsNull(owner, "owner"))
{
return;
}
float altitude = owner.GetCharacterPosition().Position.y;
foreach (string memberId in Data.Members)
{
Talespire.Minis.SetFlying(memberId, isFlying);
}
if (!isFlying)
{
foreach (string memberId in Data.Members)
{
Talespire.Log.Debug($"Moving relative...");
Talespire.Minis.MoveRelative(memberId, new Vector3(0.01f, 0, 0.01f));
}
}
}
finally
{
Talespire.Log.Unindent();
}
}
private void BoardSessionManager_OnStateChange(PhotonSimpleSingletonStateMBehaviour <BoardSessionManager> .State obj)
{
if (obj.ToString() == "Active")
{
ownerCreature = null;
}
}
public static CreatureBoardAsset GetTargetedCreature()
{
Log.Debug($"StartTargeting - InteractiveTargetingMode = {InteractiveTargetingMode}");
FlashLight flashLight = Flashlight.Get();
if (flashLight != null)
{
if (InteractiveTargetingMode == InteractiveTargetingMode.Creatures)
{
return(AddTargetToNearestCreature());
}
else if (InteractiveTargetingMode == InteractiveTargetingMode.CreatureSelect)
{
CreatureBoardAsset nearestCreature = GetNearestCreature();
Log.Debug($"nearestCreature: {nearestCreature}");
Off();
InteractiveTargetingMode = InteractiveTargetingMode.None;
return(nearestCreature);
}
else
{
DropTargetAtFlashlight();
Off();
InteractiveTargetingMode = InteractiveTargetingMode.None;
}
}
return(null);
}
public static void ClearAttached(string spellId, string creatureId)
{
CreatureBoardAsset creatureBoardAsset = Minis.GetCreatureBoardAsset(creatureId);
if (creatureBoardAsset == null)
{
Log.Error($"CreatureBoardAsset matching id {creatureId} not found!");
return;
}
GameObject creatureBase = creatureBoardAsset.GetBase();
string attachedEffectName = GetAttachedEffectName(spellId);
GameObject childEffect = creatureBase.FindChild(attachedEffectName);
if (childEffect == null)
{
Log.Error($"Child effect {attachedEffectName} not found.");
return;
}
while (childEffect != null)
{
childEffect.transform.SetParent(null);
Instances.AddTemporal(childEffect, 2, 2);
childEffect = creatureBase.FindChild(attachedEffectName);
}
}
private void ToggleGroupMembership(CreatureBoardAsset mini)
{
if (mini.CreatureId.ToString() != MiniGrouperScript.OwnerID)
{
MiniGrouperScript.ToggleMember(mini);
RefreshMemberList();
}
}
public void Set(CreatureBoardAsset creatureAsset, GameObject assetLoader, GameObject effectOrb, GameObject attachedNode, IOldPersistentEffect persistentEffect)
{
CreatureAsset = creatureAsset;
AssetLoader = assetLoader;
EffectOrb = effectOrb;
AttachedNode = attachedNode;
PersistentEffect = persistentEffect;
}
void UpdateMemberLocations(List <MemberLocation> memberLocations, CreatureBoardAsset leaderAsset)
{
foreach (MemberLocation memberLocation in memberLocations)
{
memberLocation.DistanceToLeader = (leaderAsset.PlacedPosition - memberLocation.Asset.PlacedPosition).magnitude;
memberLocation.Position = memberLocation.Asset.PlacedPosition;
}
}
private static void PlayEmote(CreatureBoardAsset creatureBoardAsset, string emote)
{
if (emote == AnimationNames.KnockDown)
{
Log.Error($"Use ToggleStatusEmote instead to animate a knock-down.");
}
creatureBoardAsset.Creature.PlayEmote(emote);
}
public static void ShowDamage(string creatureId, int damageAmount, string bloodColor, float rotationOffset = 0)
{
CreatureBoardAsset creatureAsset = GetCreatureBoardAsset(creatureId);
if (creatureAsset == null)
{
Log.Error($"ShowDamage - creatureId {creatureId} not found.");
return;
}
if (damageAmount > 30)
{
ShowDamage(creatureId, damageAmount - 30, bloodColor, random.NextInt(60) - 30);
damageAmount = 30;
}
float scale = 0.65f * creatureAsset.CreatureScale; // 0.5, 1, 2, 3, 4
string prefabName;
float scaleMultiplier;
if (damageAmount < 15)
{
prefabName = GetRandomSmallBloodPrefab();
scaleMultiplier = 1;
}
else
{
prefabName = GetRandomLargeBloodPrefab();
scaleMultiplier = 1 + damageAmount / 70f;
}
Log.Debug($"prefabName = \"{prefabName}\"");
GameObject bloodPrefab = Prefabs.Get(prefabName);
if (bloodPrefab == null)
{
Log.Error($"Prefab \"{prefabName}\" not found!");
bloodPrefab = Prefabs.Get("Blood4");
}
// TODO: Change the blood color... bloodColor
scale *= scaleMultiplier;
float groundHeight = creatureAsset.GetGroundHeight();
//Log.Debug($"groundHeight = {groundHeight}");
GameObject bloodEffect = UnityEngine.Object.Instantiate(bloodPrefab, creatureAsset.HookHitTarget.position, creatureAsset.HookHitTarget.rotation);
Property.ModifyFloat(bloodEffect, null, "<BFX_BloodSettings>.GroundHeight", groundHeight);
ChangeBloodEffectColor(bloodEffect, bloodColor);
bloodEffect.transform.Rotate(Vector3.up, 180 + rotationOffset);
bloodEffect.transform.localScale = new Vector3(scale, scale, scale);
Instances.AddTemporal(bloodEffect, 16);
}
public static void LookAt(string id, Vector3 position)
{
CreatureBoardAsset creatureBoardAsset = GetCreatureBoardAsset(id);
if (creatureBoardAsset != null)
{
creatureBoardAsset.LookAt(position);
}
}
public static void RotateTo(string id, float rotationDegrees)
{
CreatureBoardAsset creatureBoardAsset = GetCreatureBoardAsset(id);
if (creatureBoardAsset != null)
{
creatureBoardAsset.SetRotationDegrees(rotationDegrees);
}
}
private void LookAt(List <CreatureBoardAsset> assets, CreatureBoardAsset target)
{
if (target != null)
{
foreach (CreatureBoardAsset asset in assets)
{
asset.RotateToFacePosition(target.PlacedPosition);
}
}
}
// 
public static int GetBaseColorIndex(string id)
{
CreatureBoardAsset creatureBoardAsset = GetCreatureBoardAsset(id);
if (creatureBoardAsset == null)
{
return(0);
}
return(creatureBoardAsset.GetBaseColorIndex());
}
public static bool IsPersistentEffect(string creatureId)
{
CreatureBoardAsset creatureBoardAsset = Minis.GetCreatureBoardAsset(creatureId);
if (creatureBoardAsset != null)
{
return(creatureBoardAsset.IsPersistentEffect());
}
return(false);
}
public void MarkPositionsForLiveRotation(float degreesStart)
{
degreesOffsetForRotation = degreesStart;
CreatureBoardAsset leaderAsset = OwnerCreature;
if (Guard.IsNull(leaderAsset, "leaderAsset"))
{
return;
}
memberLocationsBeforeRotation = GetMemberLocations(leaderAsset);
}
public static GameObject GetEffectOrb(CreatureBoardAsset creatureBoardAsset)
{
GameObject effectOrb = null;
GameObject assetLoader = creatureBoardAsset.GetAssetLoader();
if (assetLoader != null)
{
effectOrb = assetLoader.FindChild(STR_EffectOrb, true);
}
return(effectOrb);
}
public void ToggleMember(CreatureBoardAsset creatureBoardAsset)
{
if (Data.Members.Contains(creatureBoardAsset.CreatureId.ToString()))
{
RemoveMember(creatureBoardAsset);
}
else
{
AddMember(creatureBoardAsset);
}
}
public static bool HasActiveEmote(this CreatureBoardAsset asset, ActionTimeline actionTimeline)
{
CreatureDataV2 _mostRecentCreatureData = asset.GetRecentCreatureData();
if (_mostRecentCreatureData.ActiveEmoteIds == null)
{
return(false);
}
return(_mostRecentCreatureData.ActiveEmoteIds.Contains(actionTimeline.ActionTimelineId));
}
private static string GetDisplayName(CreatureBoardAsset creatureAsset)
{
string name = creatureAsset.Creature.Name;
int indexOfSeparator = name.IndexOf(STR_RichTextSizeZero);
if (indexOfSeparator > 0)
{
return(name.Substring(0, indexOfSeparator));
}
return(name);
}
