public void ApplyTask(GameObject go)
{
/*
*
*/
if (targets.Count > 0)
{
Transform myTransform = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(go.transform, myNode);
List <AudioClip> acList = new List <AudioClip>();
if (myTransform != null)
{
foreach (var target in targets)
{
switch (type)
{
case AudioType.ZSFX:
var myZSFX = myTransform.GetComponent <ZSFX>();
if (myZSFX != null)
{
if (myTransform != null)
{
var targetZSFX = myTransform.GetComponent <ZSFX>();
if (targetZSFX != null)
{
if (target.targetIndex != -1)
{
}
else
{
foreach (var ac in targetZSFX.m_audioClips)
{
acList.Add(ac);
}
}
//myZSFX.m_audioClips[0]
}
}
}
break;
case AudioType.AudioSource:
break;
}
}
}
}
}
private void FixParticleSystemRendererReferences(GameObject gameObject, GameObjectNode node)
{
if (node.copyParticles)
{
ParticleSystemRenderer myPSR;
ParticleSystemRenderer targetPSR = null;
myPSR = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(gameObject.transform, node.myNode).gameObject.GetComponent <ParticleSystemRenderer>();
if (MyReferences.targetParticleSystemRenderers.ContainsKey(savedTargetPrefabNode.GetStableHashCode()))
{
targetPSR = MyReferences.targetParticleSystemRenderers[savedTargetPrefabNode.GetStableHashCode()];
}
else
{
GameObject targetedNode;
if (MyReferences.targetPrefabNodes.ContainsKey((node.targetPrefab + node.targetNode).GetStableHashCode()))
{
targetedNode = MyReferences.targetPrefabNodes[(node.targetPrefab + node.targetNode).GetStableHashCode()];
targetPSR = targetedNode.GetComponent <ParticleSystemRenderer>();
if (targetPSR != null)
{
MyReferences.targetParticleSystemRenderers.Add(savedTargetPrefabNode.GetStableHashCode(), targetPSR);
}
}
else
{
var referencedGameObject = MyReferences.listOfAllGameObjects[node.targetPrefab.GetStableHashCode()];
targetedNode = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(referencedGameObject.transform, node.targetNode).gameObject;
if (targetedNode != null)
{
MyReferences.targetPrefabNodes.Add(savedTargetPrefabNode.GetStableHashCode(), targetedNode);
targetPSR = targetedNode.GetComponent <ParticleSystemRenderer>();
}
}
}
myPSR.sharedMaterial = targetPSR.sharedMaterial;
}
}
public void ApplyEffects(GameObject gameObject)
{
//Set item particle material
//try
//{
// gameObject.GetComponent<ParticleSystemRenderer>().material = AssetReferences.listOfMaterials["item_particle"];
//}
//catch (Exception e)
//{
// Plugin.Log.LogError($"Error getting item spark particle effect material from material list");
// Plugin.Log.LogError($"Catch Exception details: {e.Message} --- {e.StackTrace}");
//}
ParticleSystemRenderer ps = gameObject.GetComponent <ParticleSystemRenderer>();
if (ps != null)
{
ps.sharedMaterial = MyReferences.listOfMaterials["item_particle".GetStableHashCode()];
}
Transform thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(gameObject.transform, "attach");
if (thing != null)
{
thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(thing, "equiped");
if (thing != null)
{
Transform trail = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(thing, "trail");
if (trail != null)
{
MeleeWeaponTrail mwt = trail.gameObject.GetComponent <MeleeWeaponTrail>();
mwt._material = MyReferences.listOfMaterials["club_trail".GetStableHashCode()];
}
}
}
var gameObjectShared = gameObject.GetComponent <ItemDrop>().m_itemData.m_shared;
if (pendingStatusEffects.Count > 0)
{
try
{
foreach (PendingStatusEffect pendingStatusEffect in pendingStatusEffects)
{
StatusEffect EffectToApply = null;
GameObject targetPrefab = null;
if (pendingStatusEffect.targetFrom != StatusEffectTarget.ODB)
{
targetPrefab = MyReferences.listOfAllGameObjects[pendingStatusEffect.prefabTarget.GetStableHashCode()];
if (targetPrefab == null)
{
targetPrefab = ObjectDB.instance.GetItemPrefab(pendingStatusEffect.prefabTarget);
}
if (targetPrefab == null)
{
continue;
}
}
switch (pendingStatusEffect.targetFrom)
{
case StatusEffectTarget.ODB:
EffectToApply = ObjectDB.instance.GetStatusEffect(pendingStatusEffect.prefabTarget);
break;
case StatusEffectTarget.SET:
EffectToApply = targetPrefab.GetComponent <ItemDrop>().m_itemData.m_shared.m_setStatusEffect;
break;
case StatusEffectTarget.EQUIP:
EffectToApply = targetPrefab.GetComponent <ItemDrop>().m_itemData.m_shared.m_equipStatusEffect;
break;
case StatusEffectTarget.ATTACK:
EffectToApply = targetPrefab.GetComponent <ItemDrop>().m_itemData.m_shared.m_attackStatusEffect;
break;
}
if (EffectToApply != null)
{
switch (pendingStatusEffect.targetTo)
{
case StatusEffectTarget.SET:
gameObjectShared.m_setStatusEffect = EffectToApply;
break;
case StatusEffectTarget.EQUIP:
gameObjectShared.m_equipStatusEffect = EffectToApply;
break;
case StatusEffectTarget.ATTACK:
gameObjectShared.m_attackStatusEffect = EffectToApply;
break;
}
}
}
}
catch (Exception e)
{
Plugin.Log.LogError($"Error Trying to fix status effect reference {e.Message}");
}
}
if (pendingEffects.Count > 0)
{
//Set item attack trail material
//try
//{
// PrefabNodeManager.RecursiveChildNodeFinder(gameObject.transform, "trail").gameObject.GetComponent<MeleeWeaponTrail>()._material = AssetReferences.listOfMaterials["club_trail"];
//}
//catch (Exception e)
//{
// Plugin.Log.LogError($"Error getting weapon trail effect material from material list");
// Plugin.Log.LogError($"Catch Exception details: {e.Message} --- {e.StackTrace}");
//}
foreach (PendingEffect pendingEffect in pendingEffects)
{
EffectData effectData = new EffectData();
effectData.m_enabled = true;
try
{
effectData.m_prefab = MyReferences.listOfEffects[pendingEffect.effectName.GetStableHashCode()];
}
catch (Exception e)
{
Plugin.Log.LogError($"Error getting effect {pendingEffect.effectName} from effect list");
Plugin.Log.LogError($"Catch Exception details: {e.Message} --- {e.StackTrace}");
}
switch (pendingEffect.list)
{
case EffectList.HIT:
hitEffectsData.Add(effectData);
break;
case EffectList.HIT_TERRAIN:
hitterrainEffectsData.Add(effectData);
break;
case EffectList.BLOCK:
blockEffectsData.Add(effectData);
break;
case EffectList.START:
startEffectsData.Add(effectData);
break;
case EffectList.HOLD:
holdEffectsData.Add(effectData);
break;
case EffectList.TRIGGER:
triggerEffectsData.Add(effectData);
break;
case EffectList.TRAIL:
trailEffectsData.Add(effectData);
break;
}
}
}
gameObjectShared.m_hitEffect.m_effectPrefabs = hitEffectsData.ToArray();
gameObjectShared.m_hitTerrainEffect.m_effectPrefabs = hitterrainEffectsData.ToArray();
gameObjectShared.m_blockEffect.m_effectPrefabs = blockEffectsData.ToArray();
gameObjectShared.m_startEffect.m_effectPrefabs = startEffectsData.ToArray();
gameObjectShared.m_holdStartEffect.m_effectPrefabs = holdEffectsData.ToArray();
gameObjectShared.m_triggerEffect.m_effectPrefabs = triggerEffectsData.ToArray();
gameObjectShared.m_trailStartEffect.m_effectPrefabs = trailEffectsData.ToArray();
WipeLists();
}
private static void GenerateReferenceLists()
{
//Start surfing through all items
foreach (GameObject go in ObjectDB.instance.m_items)
{
//Add to reference lists if not in their already
MyReferences.TryAddToItemList(go);
ItemDrop id = go.GetComponent <ItemDrop>();
if (id != null)
{
//var s = id.m_itemData.m_shared;
//Log.LogMessage($"{id.name},{s.m_weight},{s.m_attackForce}");
ParticleSystemRenderer ps = go.GetComponent <ParticleSystemRenderer>();
if (ps != null)
{
if (!MyReferences.listOfMaterials.ContainsKey("item_particle".GetStableHashCode()))
{
MyReferences.TryAddToMaterialList(ps.sharedMaterial, "item_particle");
}
}
var shared = id.m_itemData.m_shared;
//Start looking for weapon effects (fx, sfx, vfx)
if (shared.m_itemType == ItemDrop.ItemData.ItemType.OneHandedWeapon ||
shared.m_itemType == ItemDrop.ItemData.ItemType.TwoHandedWeapon ||
shared.m_itemType == ItemDrop.ItemData.ItemType.Bow)
{
if (!MyReferences.listOfMaterials.ContainsKey("club_trail".GetStableHashCode()))
{
Transform thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(go.transform, "attach");
if (thing != null)
{
thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(thing, "equiped");
if (thing != null)
{
Transform trail = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(thing, "trail");
if (trail != null)
{
MeleeWeaponTrail mwt = trail.gameObject.GetComponent <MeleeWeaponTrail>();
MyReferences.TryAddToMaterialList(mwt._material, "club_trail");
}
}
}
}
MyReferences.TryExtractEffectsFromItemDropShared(shared);
}
//Check to see if item can also build things
if (shared.m_buildPieces != null)
{
var pieceTable = shared.m_buildPieces.m_pieces;
if (pieceTable != null)
{
foreach (var pieceTableItem in pieceTable)
{
MyReferences.TryAddToPieceList(pieceTableItem);
//One off capture of a station extension's line effect
StationExtension stationExtension = pieceTableItem.GetComponent <StationExtension>();
if (stationExtension != null && !MyReferences.listOfEffects.ContainsKey(stationExtension.m_connectionPrefab.name.GetStableHashCode()))
{
MyReferences.listOfEffects.Add(stationExtension.m_connectionPrefab.name.GetStableHashCode(), stationExtension.m_connectionPrefab);
}
//Collect this for items and pieces, for proper referencing
CraftingStation craftingStation = pieceTableItem.GetComponent <CraftingStation>();
if (craftingStation != null && !MyReferences.listOfCraftingStations.ContainsKey(pieceTableItem.name.GetStableHashCode()))
{
MyReferences.listOfCraftingStations.Add(pieceTableItem.name.GetStableHashCode(), craftingStation);
}
CookingStation cookingStation = pieceTableItem.GetComponent <CookingStation>();
if (cookingStation != null && !MyReferences.listOfCookingStations.ContainsKey(pieceTableItem.name.GetStableHashCode()))
{
MyReferences.listOfCookingStations.Add(pieceTableItem.name.GetStableHashCode(), cookingStation);
}
//Extracting any Piece Placement Effects
var PieceScript = pieceTableItem.GetComponent <Piece>();
if (PieceScript != null)
{
ExtractEffectsFromPiece(PieceScript.m_placeEffect);
}
//Extracting WearNTear effects
var WearNTearScript = pieceTableItem.GetComponent <WearNTear>();
if (WearNTearScript != null)
{
ExtractEffectsFromPiece(WearNTearScript.m_destroyedEffect);
ExtractEffectsFromPiece(WearNTearScript.m_hitEffect);
ExtractEffectsFromPiece(WearNTearScript.m_switchEffect);
}
}
}
}
}
}
}
private void FixMaterialReferences(GameObject gameObject, GameObjectNode node)
{
try
{
if (node.copyMaterial)
{
//Plugin.Log.LogMessage($"Material to Fix for Prefab: {gameObject.name} for child: {node.myNode}");
Dictionary <int, Material> newMatArray = new Dictionary <int, Material>();
List <Transform> myNodes = new List <Transform>();
List <Renderer> myRenderers = new List <Renderer>();
Renderer targetRenderer = null;
RecursiveSearchFunctions.ChildNodesFinderDepthFirst(gameObject.transform, node.myNode, node.numberOfNodes, ref myNodes);
//Plugin.Log.LogMessage($"Number of children found: {myNodes.Count}");
if (myNodes.Count == 0)
{
return;
}
//Extract all Renderers
foreach (Transform myNode in myNodes)
{
var renderer = myNode.GetComponent <MeshRenderer>();
if (renderer != null)
{
myRenderers.Add(renderer);
continue;
}
var renderer2 = myNode.GetComponent <SkinnedMeshRenderer>();
if (renderer2 != null)
{
myRenderers.Add(renderer2);
continue;
}
Plugin.Log.LogWarning($"Wasn't able to find renderer for {node.myNode} inside of {gameObject.name}");
}
foreach (var mt in node.materialTasks)
{
string mySavedNewMatName = gameObject.name + node.targetPrefab + "_newMat_" + mt.myMaterialIndex;
//If Material Exists Extract it
if (MyReferences.newMaterials.ContainsKey(mySavedNewMatName.GetStableHashCode()))
{
newMatArray.Add(mt.myMaterialIndex, MyReferences.newMaterials[mySavedNewMatName.GetStableHashCode()]);
}
}
if (newMatArray.Count > 0)
{
Material[] materials = null;
foreach (Renderer myRenderer in myRenderers)
{
if (materials == null)
{
materials = myRenderer.sharedMaterials;
foreach (var mt in node.materialTasks)
{
materials[mt.myMaterialIndex] = newMatArray[mt.myMaterialIndex];
}
}
myRenderer.sharedMaterials = materials;
}
}
//Start looking for the TargetMaterial
string targetNodeName = node.targetPrefab + node.targetNode;
GameObject targetedNode;
if (MyReferences.targetPrefabNodes.ContainsKey(targetNodeName.GetStableHashCode()))
{
//Plugin.Log.LogMessage($"Found saved target node: {targetNodeName}");
targetedNode = MyReferences.targetPrefabNodes[targetNodeName.GetStableHashCode()];
if (targetedNode.GetComponent <MeshRenderer>() != null)
{
//Plugin.Log.LogMessage($"Found Skinned Mesh Renderer");
targetRenderer = targetedNode.GetComponent <MeshRenderer>();
}
else if (targetedNode.GetComponent <SkinnedMeshRenderer>() != null)
{
//Plugin.Log.LogMessage($"Found Skinned Mesh Renderer");
targetRenderer = targetedNode.GetComponent <SkinnedMeshRenderer>();
}
}
else
{
//Plugin.Log.LogMessage($"Searching for target node: {targetNodeName}");
var referencedGameObject = MyReferences.listOfAllGameObjects[node.targetPrefab.GetStableHashCode()];
targetedNode = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(referencedGameObject.transform, node.targetNode).gameObject;
if (targetedNode != null)
{
if (targetedNode.GetComponent <MeshRenderer>() != null)
{
//Plugin.Log.LogMessage($"Found Mesh Renderer");
targetRenderer = targetedNode.GetComponent <MeshRenderer>();
}
else if (targetedNode.GetComponent <SkinnedMeshRenderer>() != null)
{
//Plugin.Log.LogMessage($"Found Skinned Mesh Renderer");
targetRenderer = targetedNode.GetComponent <SkinnedMeshRenderer>();
}
}
}
foreach (var renderer in myRenderers)
{
Material[] mats = null;
if (mats == null)
{
mats = renderer.sharedMaterials;
foreach (var mt in node.materialTasks)
{
if (mt.copyShaderOnly)
{
mats[mt.myMaterialIndex].shader = targetRenderer.sharedMaterials[mt.targetMaterialIndex].shader;
continue;
}
if (mt.copyTexturesOnly)
{
//need to create an array/list of what textures and colors
mats[mt.myMaterialIndex].SetTexture("_MainTex", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetTexture("_MainTex"));
mats[mt.myMaterialIndex].SetTexture("_BumpMap", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetTexture("_BumpMap"));
mats[mt.myMaterialIndex].SetTexture("_MetallicGlossMap", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetTexture("_MetallicGlossMap"));
mats[mt.myMaterialIndex].SetTexture("_EmissionMap", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetTexture("_EmissionMap"));
mats[mt.myMaterialIndex].SetColor("_Color", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetColor("_Color"));
mats[mt.myMaterialIndex].SetColor("_EmissionColor", targetRenderer.sharedMaterials[mt.targetMaterialIndex].GetColor("_EmissionColor"));
continue;
}
if (mt.useMyTextures || mt.replaceColor || mt.replaceEmissionColor || mt.replaceMetalColor || mt.UpdateTextureScaleOffset)
{
/* Valid Texture Names
* _BumpMap (normals)
* _DetailAlbedoMap
* _DetailMask
* _DetailNormalMap
* _EmissionMap
* _MainTex (diffuse,albedo)
* _MetallicGlossMap
* _OcclusionMap
* _ParallaxMap
*/
/* Valid Color Ids
* _Color
* _EmissionColor
* _MetalColor *for 'Custom/Creature'
*/
string mySavedNewMatName = gameObject.name + node.targetPrefab + "_newMat_" + mt.myMaterialIndex;
Material newMat = new Material(targetRenderer.sharedMaterials[mt.targetMaterialIndex]);
newMat.name = mySavedNewMatName;
if (mt.useMyTextures)
{
newMat.SetTexture("_MainTex", renderer.sharedMaterials[mt.myMaterialIndex].GetTexture("_MainTex"));
newMat.SetTexture("_MetallicGlossMap", renderer.sharedMaterials[mt.myMaterialIndex].GetTexture("_MetallicGlossMap"));
newMat.SetTexture("_BumpMap", renderer.sharedMaterials[mt.myMaterialIndex].GetTexture("_BumpMap"));
}
if (mt.replaceColor)
{
newMat.SetColor("_Color", mt.mainTextureColor);
}
if (mt.replaceEmissionColor)
{
newMat.SetColor("_EmissionColor", mt.emissionColor);
}
if (mt.replaceMetalColor)
{
newMat.SetColor("_MetalColor", mt.metalColor);
}
if (mt.UpdateTextureScaleOffset)
{
newMat.mainTextureScale = new Vector2(mt.textureScaleX, mt.textureScaleY);
newMat.mainTextureOffset = new Vector2(mt.TextureOffsetX, mt.TextureOffsetY);
}
if (!MyReferences.newMaterials.ContainsKey(mySavedNewMatName.GetStableHashCode()))
{
MyReferences.newMaterials.Add(mySavedNewMatName.GetStableHashCode(), newMat);
}
//Plugin.Log.LogMessage($"Building newMat array");
//RendererTest
if (mats.Length > 1)
{
//Plugin.Log.LogMessage($"Setting material array with newMat array");
mats[mt.myMaterialIndex] = newMat;
}
else
{
mats = new Material[] { newMat }
};
}
else //Just 100% use the same materials
{
//Will have to revist this, As I could have more options for say 3 material items.
//Plugin.Log.LogMessage($"Setting material array with target material array");
if (mats.Length > 1)
{
mats[mt.myMaterialIndex] = targetRenderer.sharedMaterials[mt.targetMaterialIndex];
}
else
{
mats = targetRenderer.sharedMaterials;
}
}
}
}
renderer.sharedMaterials = mats;
}
}
}
catch (Exception e)
{
Plugin.Log.LogError($"Error trying to fix material reference for {gameObject.name}");
Plugin.Log.LogError(e.Message);
Plugin.Log.LogError(e.StackTrace);
}
}
private void FixMeshReferences(GameObject gameObject, GameObjectNode node)
{
if (node.copyMesh)
{
MeshFilter targetFilter = null;
//Gather all child transforms from main prefab
List <Transform> foundNodes = new List <Transform>();
RecursiveSearchFunctions.ChildNodesFinderDepthFirst(gameObject.transform, node.myNode, node.numberOfNodes, ref foundNodes);
if (foundNodes.Count == 0)
{
return; //If this didn't find anything, either via typo or wrong name, just exit
}
//Extract all the mesh filters from the found main prefab node(s)
List <MeshFilter> mfs = new List <MeshFilter>();
foreach (var foundNode in foundNodes)
{
if (node.replaceMeshScale)
{
foundNode.localScale = new Vector3(node.scaleMeshX, node.scaleMeshY, node.scaleMeshZ);
}
MeshFilter mf = foundNode.GetComponent <MeshFilter>();
if (mf != null)
{
mfs.Add(mf);
}
}
if (mfs.Count == 0)
{
return; //No Mesh filters, just exit
}
//Has the Target prefab's Mesh Filter been looked up before?
if (MyReferences.targetMeshFilters.ContainsKey(savedTargetPrefabNode.GetStableHashCode()))
{
targetFilter = MyReferences.targetMeshFilters[savedTargetPrefabNode.GetStableHashCode()];
}
else
{
GameObject targetedNode;
//If this Target Prefab and it's Node been looked up, use that to get the Mesh Filter
if (MyReferences.targetPrefabNodes.ContainsKey(savedTargetPrefabNode.GetStableHashCode()))
{
targetedNode = MyReferences.targetPrefabNodes[savedTargetPrefabNode.GetStableHashCode()];
targetFilter = targetedNode.GetComponent <MeshFilter>();
//If this reference isn't saved, save it for later
if (targetFilter != null)
{
MyReferences.targetMeshFilters.Add(savedTargetPrefabNode.GetStableHashCode(), targetFilter);
}
}
else
{
//Look up Target Prefab and extract the Node
var referencedGameObject = MyReferences.listOfAllGameObjects[node.targetPrefab.GetStableHashCode()];
targetedNode = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(referencedGameObject.transform, node.targetNode).gameObject;
if (targetedNode != null)
{
MyReferences.targetPrefabNodes.Add(savedTargetPrefabNode.GetStableHashCode(), targetedNode);
targetFilter = targetedNode.GetComponent <MeshFilter>();
}
}
}
foreach (var mf in mfs)
{
mf.mesh = targetFilter.mesh;
}
}
}
