public static CharacterModel.RendererInfo CreateRendererInfo(Renderer r, Material m, System.Boolean ignoreOverlays, UnityEngine.Rendering.ShadowCastingMode shadow)
{
CharacterModel.RendererInfo ren = new CharacterModel.RendererInfo();
ren.renderer = r;
ren.defaultMaterial = m;
ren.ignoreOverlays = ignoreOverlays;
ren.defaultShadowCastingMode = shadow;
return(ren);
}
private void ApplySkin()
{
Hand hand = GetComponent <Hand>();
CharacterModel model = MotionControls.currentBody.modelLocator.modelTransform.GetComponent <CharacterModel>();
for (int i = 0; i < hand.rendererInfos.Length; i++)
{
var rendererInfo = hand.rendererInfos[i];
string name = rendererInfo.renderer.material.name;
if (!name.StartsWith("mat"))
{
continue;
}
if (name.EndsWith(" (Instance)"))
{
name = name.Remove(name.IndexOf(" (Instance)"));
}
CharacterModel.RendererInfo?matchingRendererInfo = model.baseRendererInfos.FirstOrDefault(x => x.defaultMaterial && (x.defaultMaterial.name == name || x.defaultMaterial.name == (name + "Alt")));
if (!matchingRendererInfo.HasValue || matchingRendererInfo.Value.defaultMaterial == null)
{
if (rendererInfo.renderer is SkinnedMeshRenderer)
{
matchingRendererInfo = model.baseRendererInfos.FirstOrDefault(x => x.renderer is SkinnedMeshRenderer && x.renderer.name == rendererInfo.renderer.name);
if (matchingRendererInfo == null)
{
continue;
}
}
else
{
continue;
}
}
CharacterModel.RendererInfo bodyRendererInfo = matchingRendererInfo.Value;
if (bodyRendererInfo.defaultMaterial)
{
rendererInfo.renderer.material = bodyRendererInfo.defaultMaterial;
rendererInfo.defaultMaterial = bodyRendererInfo.defaultMaterial;
hand.rendererInfos[i] = rendererInfo;
}
else
{
VRMod.StaticLogger.LogWarning("No replacement found for " + name + ".");
}
}
}
private static CharacterModel.RendererInfo[] SkinRendererInfos(CharacterModel.RendererInfo[] defaultRenderers, Material[] materials)
{
CharacterModel.RendererInfo[] newRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(newRendererInfos, 0);
newRendererInfos[0].defaultMaterial = materials[0];
newRendererInfos[instance.mainRendererIndex].defaultMaterial = materials[2];
return(newRendererInfos);
}
private static CharacterModel.RendererInfo[] SkinRendererInfos(CharacterModel.RendererInfo[] defaultRenderers, Material[] materials)
{
CharacterModel.RendererInfo[] newRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(newRendererInfos, 0);
newRendererInfos[0].defaultMaterial = Modules.Assets.CreateMaterial("matHenryAlt");
newRendererInfos[1].defaultMaterial = Modules.Assets.CreateMaterial("matHenryAlt");
newRendererInfos[2].defaultMaterial = Modules.Assets.CreateMaterial("matHenryAlt");
return(newRendererInfos);
}
private void UpdateMaterial(CharacterModel model, Material newMat)
{
CharacterModel.RendererInfo[] rendererInfos = model.baseRendererInfos;
CharacterModel.RendererInfo bodyInfo = rendererInfos[model.baseRendererInfos.Length - 1];
CharacterModel.RendererInfo swordInfo = rendererInfos[0];
bodyInfo.defaultMaterial = newMat;
swordInfo.defaultMaterial = newMat;
rendererInfos.SetValue(bodyInfo, model.baseRendererInfos.Length - 1);
rendererInfos.SetValue(swordInfo, 0);
model.baseRendererInfos = rendererInfos;
}
private void SetRendererInfos(CharacterModel model)
{
CharacterModel.RendererInfo[] modelInfos = model.baseRendererInfos;
CharacterModel.RendererInfo[] hatInfos = new CharacterModel.RendererInfo[2];
Material banditMaterial = modelInfos[_bandit1 ? 0 : 3].defaultMaterial;//Reflection.GetFieldValue<SkinnedMeshRenderer>(model, "mainSkinnedMeshRenderer").material;
for (int i = 0; i < _hatRescale.hatRenderers.Length; i++)
{
hatInfos[i] = new CharacterModel.RendererInfo {
defaultMaterial = banditMaterial,
renderer = _hatRescale.hatRenderers[i],
defaultShadowCastingMode = ShadowCastingMode.On,
ignoreOverlays = false
};
}
model.baseRendererInfos = modelInfos.Concat(hatInfos).ToArray();
}
internal static CharacterModel.RendererInfo[] SetupRendererInfos(GameObject obj)
{
MeshRenderer[] meshes = obj.GetComponentsInChildren <MeshRenderer>();
CharacterModel.RendererInfo[] rendererInfos = new CharacterModel.RendererInfo[meshes.Length];
for (int i = 0; i < meshes.Length; i++)
{
rendererInfos[i] = new CharacterModel.RendererInfo
{
defaultMaterial = meshes[i].material,
renderer = meshes[i],
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = false
};
}
return(rendererInfos);
}
public static CharacterModel.RendererInfo[] ItemDisplaySetup(GameObject obj)
{
MeshRenderer[] meshes = obj.GetComponentsInChildren <MeshRenderer>();
CharacterModel.RendererInfo[] renderInfos = new CharacterModel.RendererInfo[meshes.Length];
for (int i = 0; i < meshes.Length; i++)
{
renderInfos[i] = new CharacterModel.RendererInfo
{
defaultMaterial = meshes[i].material,
renderer = meshes[i],
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = false //We allow the mesh to be affected by overlays like OnFire or PredatoryInstinctsCritOverlay.
};
}
return(renderInfos);
}
public static void RegisterSkins()
{
GameObject bodyPrefab = Templar.myCharacter;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = Reflection.GetFieldValue <SkinnedMeshRenderer>(characterModel, "mainSkinnedMeshRenderer");
#region Default Skin
LanguageAPI.Add("Templar_DEFAULT_SKIN", "Default");
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = Array.Empty <SkinDef>();
skinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(new Color(0.64f, 0.31f, 0.22f), new Color(0.54f, 0.21f, 0.12f), new Color(0.64f, 0.31f, 0.22f), new Color(0.54f, 0.21f, 0.12f));
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
skinDefInfo.Name = "Templar_DEFAULT_SKIN";
skinDefInfo.NameToken = "Templar_DEFAULT_SKIN";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
CharacterModel.RendererInfo[] rendererInfos = skinDefInfo.RendererInfos;
CharacterModel.RendererInfo[] array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
Material material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/ClayBruiserBody").GetComponentInChildren <CharacterModel>().baseRendererInfos[0].defaultMaterial);
array[0].defaultMaterial = material;
}
skinDefInfo.RendererInfos = array;
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
#endregion
var skinDefs = new List <SkinDef>()
{
defaultSkin
};
skinController.skins = skinDefs.ToArray();
}
/// <summary>
/// A helper that will set up the RendererInfos of a GameObject that you pass in.
/// <para>This allows it to go invisible when your character is not visible, as well as letting overlays affect it.</para>
/// </summary>
/// <param name="obj">The GameObject/Prefab that you wish to set up RendererInfos for.</param>
/// <param name="debugmode">Do we attempt to attach a material shader controller instance to meshes in this?</param>
/// <returns>Returns an array full of RendererInfos for GameObject.</returns>
public static CharacterModel.RendererInfo[] ItemDisplaySetup(GameObject obj, bool debugmode = false)
{
List <Renderer> AllRenderers = new List <Renderer>();
var meshRenderers = obj.GetComponentsInChildren <MeshRenderer>();
if (meshRenderers.Length > 0)
{
AllRenderers.AddRange(meshRenderers);
}
var skinnedMeshRenderers = obj.GetComponentsInChildren <SkinnedMeshRenderer>();
if (skinnedMeshRenderers.Length > 0)
{
AllRenderers.AddRange(skinnedMeshRenderers);
}
CharacterModel.RendererInfo[] renderInfos = new CharacterModel.RendererInfo[AllRenderers.Count];
for (int i = 0; i < AllRenderers.Count; i++)
{
if (debugmode)
{
var controller = AllRenderers[i].gameObject.AddComponent <MaterialControllerComponents.HGControllerFinder>();
controller.Renderer = AllRenderers[i];
}
renderInfos[i] = new CharacterModel.RendererInfo
{
defaultMaterial = AllRenderers[i] is SkinnedMeshRenderer ? AllRenderers[i].sharedMaterial : AllRenderers[i].material,
renderer = AllRenderers[i],
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = false //We allow the mesh to be affected by overlays like OnFire or PredatoryInstinctsCritOverlay.
};
}
return(renderInfos);
}
public static void RegisterSkins()
{
GameObject bodyPrefab = Prefabs.paladinPrefab;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = characterModel.mainSkinnedMeshRenderer;
GameObject displayPrefab = Prefabs.paladinDisplayPrefab;
ChildLocator displayChildLocator = displayPrefab.GetComponent <ChildLocator>();
paladinCSSPreviewController = displayPrefab.GetComponent <CharacterSelectSurvivorPreviewDisplayController>();
paladinCSSPreviewController.bodyPrefab = bodyPrefab;
defaultResponses = paladinCSSPreviewController.skinChangeResponses;
List <SkinDef> skinDefs = new List <SkinDef>();
GameObject cape = childLocator.FindChild("Cape").gameObject;
GameObject armLeft = childLocator.FindChild("CreepyArmsLeft").gameObject;
GameObject armRight = childLocator.FindChild("CreepyArmsRight").gameObject;
GameObject fuckingCrystalCrown = childLocator.FindChild("F****e").gameObject;
allGameObjectActivations.Add(cape);
allGameObjectActivations.Add(armLeft);
allGameObjectActivations.Add(armRight);
allGameObjectActivations.Add(fuckingCrystalCrown);
SkinDef.GameObjectActivation[] defaultActivations = getActivations();
SkinDef.GameObjectActivation[] capeActivations = getActivations(cape);
SkinDef.GameObjectActivation[] nkuhanaActivations = getActivations(armLeft, armRight);
SkinDef.GameObjectActivation[] GMActivations = getActivations(cape, fuckingCrystalCrown);
#region DefaultSkin
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
int lastRend = defaultRenderers.Length - 1;
SkinDef defaultSkin = CreateSkinDef("PALADINBODY_DEFAULT_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMainSkin"), defaultRenderers, mainRenderer, model);
defaultSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.defaultMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.defaultSwordMesh,
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.defaultCapeMesh,
renderer = defaultRenderers[1].renderer
},
};
if (Modules.Config.cape.Value)
{
defaultSkin.gameObjectActivations = capeActivations;
childLocator.FindChild("Cape").gameObject.SetActive(true);
}
else
{
defaultSkin.gameObjectActivations = defaultActivations;
}
AddCSSSkinChangeResponse(defaultSkin, paladinCSSEffect.DEFAULT);
skinDefs.Add(defaultSkin);
#endregion
#region MasterySkin(lunar)
CharacterModel.RendererInfo[] masteryRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(masteryRendererInfos, 0);
// add the passive effect
#region clone mithrix effect
GameObject lunarPassiveEffect = GameObject.Instantiate(Resources.Load <GameObject>("Prefabs/CharacterBodies/BrotherBody").GetComponentInChildren <ChildLocator>().FindChild("Phase3HammerFX").gameObject);
lunarPassiveEffect.transform.parent = childLocator.FindChild("SwordActiveEffectLunar");
lunarPassiveEffect.transform.localScale = Vector3.one * 0.0002f;
lunarPassiveEffect.transform.rotation = Quaternion.Euler(new Vector3(45, 90, 0));
lunarPassiveEffect.transform.localPosition = new Vector3(0, 0, -0.003f);
lunarPassiveEffect.gameObject.SetActive(true);
lunarPassiveEffect.transform.Find("Amb_Fire_Ps, Left").localScale = Vector3.one * 0.6f;
lunarPassiveEffect.transform.Find("Amb_Fire_Ps, Right").localScale = Vector3.one * 0.6f;
lunarPassiveEffect.transform.Find("Core, Light").localScale = Vector3.one * 0.1f;
lunarPassiveEffect.transform.Find("Blocks, Spinny").localScale = Vector3.one * 0.4f;
lunarPassiveEffect.transform.Find("Sparks").localScale = Vector3.one * 0.4f;
lunarPassiveEffect = GameObject.Instantiate(lunarPassiveEffect);
lunarPassiveEffect.transform.parent = displayChildLocator.FindChild("SwordActiveEffectLunar");
lunarPassiveEffect.transform.localScale = Vector3.one * 0.0002f;
lunarPassiveEffect.transform.rotation = Quaternion.Euler(new Vector3(45, 90, 0));
lunarPassiveEffect.transform.localPosition = new Vector3(0, 0, -0.003f);
lunarPassiveEffect.gameObject.SetActive(true);
#endregion
Material lunarSwordMat = CreateMaterial("matLunarSword", 0, Color.black, 1f);
lunarSwordMat.EnableKeyword("FORCE_SPEC");
lunarSwordMat.EnableKeyword("FRESNEL_EMISSION");
lunarSwordMat.SetFloat("_SpecularStrength", 1f);
masteryRendererInfos[0].defaultMaterial = lunarSwordMat;
//masteryRendererInfos[1].defaultMaterial = CreateMaterial("matLunarCape");
masteryRendererInfos[lastRend].defaultMaterial = CreateMaterial("matLunarPaladin", 5, Color.white, 1f);
SkinDef masterySkin = CreateSkinDef("PALADINBODY_LUNAR_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievement"), masteryRendererInfos, mainRenderer, model, Modules.Unlockables.paladinMasterySkinDef);
masterySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.lunarMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.lunarSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
masterySkin.gameObjectActivations = defaultActivations;
masterySkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(new Color(0.3f, 0.1f, 1f), 1.2f)//slightly darker blue than normal
}
};
AddCSSSkinChangeResponse(masterySkin, paladinCSSEffect.LUNAR);
skinDefs.Add(masterySkin);
#endregion
#region GrandMasterySkin
CharacterModel.RendererInfo[] grandMasteryRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(grandMasteryRendererInfos, 0);
grandMasteryRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinGMSword", StaticValues.maxSwordGlow, Color.white);
grandMasteryRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinGM", 10, Color.white);
grandMasteryRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinGM", 10, Color.white);
SkinDef grandMasterySkin = CreateSkinDef("PALADINBODY_TYPHOON_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texGrandMasteryAchievement"), grandMasteryRendererInfos, mainRenderer, model, Modules.Unlockables.paladinGrandMasterySkinDef);
grandMasterySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.gmMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.gmSwordMesh,
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.gmCapeMesh,
renderer = defaultRenderers[1].renderer
}
};
grandMasterySkin.gameObjectActivations = GMActivations;
AddCSSSkinChangeResponse(grandMasterySkin, paladinCSSEffect.BEEFY);
if (PaladinPlugin.starstormInstalled)
{
skinDefs.Add(grandMasterySkin);
}
#endregion
#region PoisonSkin
CharacterModel.RendererInfo[] poisonRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(poisonRendererInfos, 0);
poisonRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinNkuhanaScythe", StaticValues.maxSwordGlow, Color.white);
poisonRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinNkuhana", 3, Color.white);
SkinDef poisonSkin = CreateSkinDef("PALADINBODY_POISON_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texPoisonAchievement"), poisonRendererInfos, mainRenderer, model, Modules.Unlockables.paladinPoisonSkinDef);
poisonSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.poisonMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.poisonSwordMesh,
renderer = defaultRenderers[0].renderer
}
//if arms are only in this skin they don't need to be mesh replacements, just gameobjectactivations
};
poisonSkin.gameObjectActivations = nkuhanaActivations;
poisonSkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(Color.green, 0.6f)
}
};
AddCSSSkinChangeResponse(poisonSkin, paladinCSSEffect.GREENSCYTHE);
skinDefs.Add(poisonSkin);
#endregion
#region ClaySkin
CharacterModel.RendererInfo[] clayRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(clayRendererInfos, 0);
clayRendererInfos[0].defaultMaterial = CreateMaterial("matClayPaladin", StaticValues.maxSwordGlow, Color.white);
clayRendererInfos[lastRend].defaultMaterial = CreateMaterial("matClayPaladin", 10, Color.white);
SkinDef claySkin = CreateSkinDef("PALADINBODY_CLAY_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texClayAchievement"), clayRendererInfos, mainRenderer, model, Modules.Unlockables.paladinClaySkinDef);
claySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.clayMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.claySwordMesh,
renderer = defaultRenderers[0].renderer
}
};
claySkin.gameObjectActivations = defaultActivations;
claySkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(new Color(1f, 0.35f, 0), 0.65f) //yello smello
}
};
AddCSSSkinChangeResponse(claySkin, paladinCSSEffect.TAR);
skinDefs.Add(claySkin);
#endregion
#region SpecterSkin
CharacterModel.RendererInfo[] specterRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(specterRendererInfos, 0);
specterRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinSpecterScythe", StaticValues.maxSwordGlow, Color.white);
specterRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinGMOld"); //HACK
specterRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinSpecter");
SkinDef specterSkin = CreateSkinDef("PALADINBODY_SPECTER_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texSpecterSkin"), specterRendererInfos, mainRenderer, model);
specterSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.specterMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.specterSwordMesh,
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.defaultCapeMesh,
renderer = defaultRenderers[1].renderer
}
};
specterSkin.gameObjectActivations = capeActivations;
specterSkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(Color.red, 0.669f)//slightly darker blue than normal
}
};
AddCSSSkinChangeResponse(specterSkin, paladinCSSEffect.REDSCYTHE);
if (Modules.Config.cursed.Value)
{
skinDefs.Add(specterSkin);
}
#endregion
#region DripSkin
CharacterModel.RendererInfo[] dripRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(dripRendererInfos, 0);
dripRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinDrip", StaticValues.maxSwordGlow, Color.white);
dripRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinDrip", 3, Color.white);
SkinDef dripSkin = CreateSkinDef("PALADINBODY_DRIP_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texDripAchievement"), dripRendererInfos, mainRenderer, model);
dripSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.dripMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.batMesh,
renderer = defaultRenderers[0].renderer
}
};
dripSkin.gameObjectActivations = defaultActivations;
AddCSSSkinChangeResponse(dripSkin, paladinCSSEffect.DEFAULT);
if (Modules.Config.cursed.Value)
{
skinDefs.Add(dripSkin);
}
#endregion
#region MinecraftSkin
CharacterModel.RendererInfo[] minecraftRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(minecraftRendererInfos, 0);
minecraftRendererInfos[0].defaultMaterial = CreateMaterial("matMinecraftSword", StaticValues.maxSwordGlow, Color.white);
minecraftRendererInfos[lastRend].defaultMaterial = CreateMaterial("matMinecraftPaladin", 3, Color.white);
SkinDef minecraftSkin = CreateSkinDef("PALADINBODY_MINECRAFT_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMinecraftSkin"), minecraftRendererInfos, mainRenderer, model);
minecraftSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.minecraftMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.minecraftSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
minecraftSkin.gameObjectActivations = defaultActivations;
AddCSSSkinChangeResponse(minecraftSkin, paladinCSSEffect.DEFAULT);
if (Modules.Config.cursed.Value)
{
skinDefs.Add(minecraftSkin);
}
#endregion
#region LunarKnightSkin(lunar)
CharacterModel.RendererInfo[] lunarKnightRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(lunarKnightRendererInfos, 0);
lunarKnightRendererInfos[0].defaultMaterial = CreateMaterial("matLunarKnight", StaticValues.maxSwordGlow, Color.white);;
lunarKnightRendererInfos[lastRend].defaultMaterial = CreateMaterial("matLunarKnight", 5, Color.white, 1f);
SkinDef lunarKnightSkin = CreateSkinDef("PALADINBODY_LUNARKNIGHT_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievementLegacy"), lunarKnightRendererInfos, mainRenderer, model, Modules.Unlockables.paladinMasterySkinDef);
lunarKnightSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.lunarKnightMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.lunarKnightSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
lunarKnightSkin.gameObjectActivations = defaultActivations;
lunarKnightSkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(new Color(0.3f, 0.1f, 1f), 1.2f)//mastery blue
}
};
AddCSSSkinChangeResponse(lunarKnightSkin, paladinCSSEffect.DEFAULT);
if (Config.legacySkins.Value)
{
skinDefs.Add(lunarKnightSkin);
}
#endregion
#region GrandMasterySkinLegacy
CharacterModel.RendererInfo[] grandMasteryLegacyRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(grandMasteryLegacyRendererInfos, 0);
grandMasteryLegacyRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinGMSwordOld", StaticValues.maxSwordGlow, Color.white);
grandMasteryLegacyRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinGMOld", 6.9f, Color.white);
grandMasteryLegacyRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinGMOld", 6.9f, Color.white);
SkinDef grandMasteryLegacySkin = CreateSkinDef("PALADINBODY_TYPHOONLEGACY_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texGrandMasteryAchievementLegacy"), grandMasteryLegacyRendererInfos, mainRenderer, model, Modules.Unlockables.paladinGrandMasterySkinDef);
grandMasteryLegacySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.gmLegacyMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.gmLegacySwordMesh,
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.defaultCapeMesh,
renderer = defaultRenderers[1].renderer
}
};
grandMasteryLegacySkin.gameObjectActivations = capeActivations;
AddCSSSkinChangeResponse(grandMasteryLegacySkin, paladinCSSEffect.BEEFY);
if (PaladinPlugin.starstormInstalled && Config.legacySkins.Value)
{
skinDefs.Add(grandMasteryLegacySkin);
}
#endregion
#region PoisonSkinLegacy
CharacterModel.RendererInfo[] poisonLegacyRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(poisonLegacyRendererInfos, 0);
poisonLegacyRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinNkuhanaLegacy", StaticValues.maxSwordGlow, Color.white);
poisonLegacyRendererInfos[lastRend].defaultMaterial = CreateMaterial("matPaladinNkuhanaLegacy", 3, Color.white);
SkinDef poisonLegacySkin = CreateSkinDef("PALADINBODY_POISONLEGACY_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texPoisonAchievementLegacy"), poisonLegacyRendererInfos, mainRenderer, model, Modules.Unlockables.paladinPoisonSkinDef);
poisonLegacySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.poisonLegacyMesh,
renderer = defaultRenderers[lastRend].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.poisonLegacySwordMesh,
renderer = defaultRenderers[0].renderer
}
//if arms are only in this skin they don't need to be mesh replaced, just activated
};
poisonLegacySkin.gameObjectActivations = defaultActivations;
poisonLegacySkin.projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[] {
new SkinDef.ProjectileGhostReplacement {
projectilePrefab = Projectiles.swordBeamProjectile,
projectileGhostReplacementPrefab = Projectiles.CloneAndColorSwordBeam(Color.green, 0.6f)
}
};
AddCSSSkinChangeResponse(poisonLegacySkin, paladinCSSEffect.GREEN);
if (Config.legacySkins.Value)
{
skinDefs.Add(poisonLegacySkin);
}
#endregion
skinController.skins = skinDefs.ToArray();
InitializeNemSkins();
}
public void AddSkin(SurvivorDef def, string SkinFolder, ConfigFile config)
{
GameObject gameObject = def.bodyPrefab;
LoadoutAPI.SkinDefInfo skinDefInfo = new LoadoutAPI.SkinDefInfo();
skinDefInfo.BaseSkins = new SkinDef[0];
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(config.Bind <Color>("", "IconColorTop", Color.magenta).Value, config.Bind <Color>("", "IconColorRight", Color.black).Value, config.Bind <Color>("", "IconColorBottom", Color.magenta).Value, config.Bind <Color>("", "IconColorLeft", Color.black).Value);
skinDefInfo.NameToken = config.Bind <string>("", "SkinName", "DefaultName").Value;
skinDefInfo.UnlockableName = config.Bind <string>("", "UnlockableName", "").Value;
skinDefInfo.RootObject = def.bodyPrefab.GetComponent <ModelLocator>().modelTransform.gameObject;
skinDefInfo.RendererInfos = new CharacterModel.RendererInfo[0];
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
skinDefInfo.GameObjectActivations = new SkinDef.GameObjectActivation[0];
skinDefInfo.Name = "SKIN_" + gameObject.name + "_DEFAULT";
int MeshReplacementIndex = config.Bind <int>("", "MeshReplacementIndex", 0).Value;
if (MeshReplacementIndex != -1)
{
skinDefInfo.MeshReplacements = gameObject.GetComponent <ModelLocator>().modelTransform.GetComponent <ModelSkinController>().skins[MeshReplacementIndex].meshReplacements;
skinDefInfo.RendererInfos = gameObject.GetComponent <ModelLocator>().modelTransform.GetComponent <ModelSkinController>().skins[MeshReplacementIndex].rendererInfos;
}
CharacterModel.RendererInfo[] rendererInfos = skinDefInfo.RendererInfos;
CharacterModel.RendererInfo[] array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
foreach (string MaterialFolder in Directory.EnumerateDirectories(SkinFolder))
{
string[] MaterialIndexVs = MaterialFolder.Split(new string[] { @"\" }, StringSplitOptions.None);
string RendererName = MaterialIndexVs[MaterialIndexVs.Length - 1];
int index = Array.IndexOf(array, array.FirstOrDefault(x => x.renderer.name == RendererName));
Material defaultMaterial = array[index].defaultMaterial;
if (defaultMaterial)
{
defaultMaterial = UnityEngine.Object.Instantiate <Material>(defaultMaterial);
foreach (string FilePath in Directory.EnumerateFiles(MaterialFolder))
{
if (FilePath.EndsWith(".PNG") || FilePath.EndsWith(".png"))
{
string[] FilePathVs = FilePath.Split(new string[] { @"\" }, StringSplitOptions.None);
string FileName = FilePathVs[FilePathVs.Length - 1].Replace(".PNG", "");
Texture2D savedTex = new Texture2D(1, 1, TextureFormat.RGBAFloat, false, true);
ImageConversion.LoadImage(savedTex, System.IO.File.ReadAllBytes(FilePath));
savedTex.Apply();
if (defaultMaterial.HasProperty(FileName))
{
defaultMaterial.enableInstancing = true;
defaultMaterial.SetTexture(FileName, GetReadableTextureCopy(savedTex));
}
}
else if (FilePath.EndsWith(".cfg"))
{
string[] ConfigPathVs = FilePath.Split(new string[] { @"\" }, StringSplitOptions.None);
string ConfigName = @"BepInEx\skins\" + ConfigPathVs[ConfigPathVs.Length - 4] + @"\" + ConfigPathVs[ConfigPathVs.Length - 3] + @"\" + ConfigPathVs[ConfigPathVs.Length - 2] + @"\" + ConfigPathVs[ConfigPathVs.Length - 1];
BepInEx.Configuration.ConfigFile perMatConfig = new ConfigFile(ConfigName, true);
{
foreach (string value in floatProperties)
{
if (defaultMaterial.HasProperty(value))
{
defaultMaterial.SetFloat(value, perMatConfig.Bind <float>("", value, defaultMaterial.GetFloat(value), new ConfigDescription("Sets the value for " + value)).Value);
}
}
foreach (string value in colorProperties)
{
if (defaultMaterial.HasProperty(value))
{
defaultMaterial.SetColor(value, perMatConfig.Bind <Color>("", value, defaultMaterial.GetColor(value), new ConfigDescription("Sets the value for " + value)).Value);
}
}
foreach (string value in defaultMaterial.shaderKeywords)
{
bool isEnabled = perMatConfig.Bind <bool>("", value, defaultMaterial.IsKeywordEnabled(value), new ConfigDescription("Sets the value for " + value)).Value;
if (isEnabled)
{
defaultMaterial.EnableKeyword(value);
}
else
{
defaultMaterial.DisableKeyword(value);
}
}
}
}
else if (FilePath.EndsWith(".obj"))
{
Mesh holderMesh = new Mesh();
ObjImporter newMesh = new ObjImporter();
holderMesh = newMesh.ImportFile(FilePath);
if (array[index].renderer.gameObject.GetComponent <MeshFilter>())
{
Array.Resize(ref skinDefInfo.MeshReplacements, skinDefInfo.MeshReplacements.Length + 1);
skinDefInfo.MeshReplacements[skinDefInfo.MeshReplacements.Length - 1].mesh = holderMesh;
skinDefInfo.MeshReplacements[skinDefInfo.MeshReplacements.Length - 1].renderer = array[index].renderer;
(skinDefInfo.MeshReplacements[skinDefInfo.MeshReplacements.Length - 1].renderer as SkinnedMeshRenderer).sharedMesh = holderMesh;
}
}
else
{
base.Logger.LogError("Unsupported file found in material folder: " + FilePath);
}
}
array[index].defaultMaterial = defaultMaterial;
}
}
base.Logger.LogInfo("Added new skin to " + def.bodyPrefab.name + " with name " + skinDefInfo.NameToken);
skinDefInfo.RendererInfos = array;
LoadoutAPI.AddSkinToCharacter(def.bodyPrefab, skinDefInfo);
SkinDef[] skins = def.bodyPrefab.GetComponent <ModelLocator>().modelTransform.GetComponent <ModelSkinController>().skins;
SkinDef[][] newSkins = typeof(BodyCatalog).GetFieldValue <SkinDef[][]>("skins");
newSkins[SurvivorCatalog.GetBodyIndexFromSurvivorIndex(def.survivorIndex)] = skins;
typeof(BodyCatalog).SetFieldValue <SkinDef[][]>("skins", newSkins);
}
internal void CreateAndAddSkin(CharacterModel model, String nameToken, String unlockableName, Sprite icon)
{
var rampTex = this.knifeTrail.OutputTextureAndDispose();
using (var skin = Skin.Create(model))
{
var snipermeshInd = -1;
var throwkinfeInd = -1;
var knifeInd = -1;
var railgunInd = -1;
var gaussgunInd = -1;
var ammomeshInd = -1;
var armormeshInd = -1;
var bodymeshInd = -1;
var cloakmeshInd = -1;
var emismeshInd = -1;
var classicRifleInd = -1;
var classicMeshInd = -1;
CharacterModel.RendererInfo[] rendInfos = skin.rendererInfos;
for (Int32 i = 0; i < rendInfos.Length; ++i)
{
CharacterModel.RendererInfo info = rendInfos[i];
Renderer smr = info.renderer;
switch (smr.name)
{
default:
#if ASSERT
Log.Warning(String.Format("{0} is not a handled renderer name", smr.name));
#endif
info.defaultMaterial = null;
break;
case "SniperMesh":
info.defaultMaterial = null;
snipermeshInd = i;
break;
case "ThrowKnife":
info.defaultMaterial = this.throwknifeMat;
throwkinfeInd = i;
break;
case "Knife":
info.defaultMaterial = this.isTrash ? null : this.knifeMat;
knifeInd = i;
break;
case "RailGun":
info.defaultMaterial = this.isTrash ? null : this.railMat;
railgunInd = i;
break;
case "GaussGun":
info.defaultMaterial = null;
gaussgunInd = i;
break;
case "AmmoMesh":
info.defaultMaterial = this.isTrash ? null : this.ammoMat;
ammomeshInd = i;
break;
case "ArmorMesh":
info.defaultMaterial = this.isTrash ? null : this.armorMat;
armormeshInd = i;
break;
case "BodyMesh":
info.defaultMaterial = this.isTrash ? null : this.bodyMat;
bodymeshInd = i;
break;
case "CloakMesh":
info.defaultMaterial = this.isTrash ? null : this.cloakMat;
cloakmeshInd = i;
break;
case "EmissionMesh":
info.defaultMaterial = this.isTrash ? null : this.emisMat;
emismeshInd = i;
break;
case "ClassicRifle":
info.defaultMaterial = !this.isTrash ? null : this.railMat;
classicRifleInd = i;
break;
case "ClassicMesh":
info.defaultMaterial = !this.isTrash ? null : this.armorMat;
classicMeshInd = i;
break;
}
rendInfos[i] = info;
}
skin.rendererInfos = rendInfos;
skin.projectileGhostReplacements = new[]
{
new SkinDef.ProjectileGhostReplacement
{
projectilePrefab = ProjectileModule.GetKnifeProjectile(),
projectileGhostReplacementPrefab = ProjectileGhostModule.GetKnifeGhost(this.throwknifeMat, MaterialModule.GetKnifeTrailMaterial(rampTex).material),
},
};
if (this.isTrash)
{
skin.gameObjectActivations = new[]
{
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[armormeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[ammomeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[bodymeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[cloakmeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[emismeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[railgunInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[knifeInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[classicMeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[classicRifleInd].renderer.gameObject,
}
};
}
else
{
skin.gameObjectActivations = new[]
{
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[armormeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[ammomeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[bodymeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[cloakmeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[emismeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[railgunInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = true,
gameObject = rendInfos[knifeInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[classicMeshInd].renderer.gameObject,
},
new SkinDef.GameObjectActivation
{
shouldActivate = false,
gameObject = rendInfos[classicRifleInd].renderer.gameObject,
}
};
}
skin.icon = icon;
skin.nameToken = nameToken;
skin.unlockableName = unlockableName;
}
var index = model.GetComponent <ModelSkinController>().skins.Length - 1;
var material = MaterialModule.GetSlashMaterial(rampTex);
VFXModule.AddKnifePickupSlash((UInt32)index, material);
}
public static void RegisterSkins()
{
GameObject bodyPrefab = Prefabs.paladinPrefab;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = characterModel.mainSkinnedMeshRenderer;
List <SkinDef> skinDefs = new List <SkinDef>();
#region DefaultSkin
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
SkinDef defaultSkin = CreateSkinDef("PALADINBODY_DEFAULT_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMainSkin"), defaultRenderers, mainRenderer, model, "");
defaultSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.defaultMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.defaultSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(defaultSkin);
#endregion
#region MasterySkin
CharacterModel.RendererInfo[] masteryRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(masteryRendererInfos, 0);
masteryRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinLunar", StaticValues.maxSwordGlow, Color.white);
masteryRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinLunar", 5, Color.white);
SkinDef masterySkin = CreateSkinDef("PALADINBODY_LUNAR_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievement"), masteryRendererInfos, mainRenderer, model, "PALADIN_MASTERYUNLOCKABLE_REWARD_ID");
masterySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.lunarMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.lunarSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(masterySkin);
#endregion
#region PoisonSkin
CharacterModel.RendererInfo[] poisonRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(poisonRendererInfos, 0);
poisonRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinNkuhana", StaticValues.maxSwordGlow, Color.white);
poisonRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinNkuhana", 3, Color.white);
SkinDef poisonSkin = CreateSkinDef("PALADINBODY_POISON_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texPoisonAchievement"), poisonRendererInfos, mainRenderer, model, "PALADIN_POISONUNLOCKABLE_REWARD_ID");
poisonSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.poisonMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.poisonSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(poisonSkin);
#endregion
#region ClaySkin
CharacterModel.RendererInfo[] clayRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(clayRendererInfos, 0);
clayRendererInfos[0].defaultMaterial = CreateMaterial("matClayPaladin", StaticValues.maxSwordGlow, Color.white);
clayRendererInfos[1].defaultMaterial = CreateMaterial("matClayPaladin");
SkinDef claySkin = CreateSkinDef("PALADINBODY_CLAY_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texClayAchievement"), clayRendererInfos, mainRenderer, model, "PALADIN_CLAYUNLOCKABLE_REWARD_ID");
claySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.clayMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.claySwordMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(claySkin);
#endregion
#region DripSkin
CharacterModel.RendererInfo[] dripRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(dripRendererInfos, 0);
dripRendererInfos[0].defaultMaterial = CreateMaterial("matPaladinDrip", StaticValues.maxSwordGlow, Color.white);
dripRendererInfos[1].defaultMaterial = CreateMaterial("matPaladinDrip", 3, Color.white);
SkinDef dripSkin = CreateSkinDef("PALADINBODY_DRIP_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texDripAchievement"), dripRendererInfos, mainRenderer, model, "PALADIN_dripUNLOCKABLE_REWARD_ID");
dripSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.dripMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.batMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(dripSkin);
#endregion
#region MinecraftSkin
CharacterModel.RendererInfo[] minecraftRendererInfos = new CharacterModel.RendererInfo[defaultRenderers.Length];
defaultRenderers.CopyTo(minecraftRendererInfos, 0);
minecraftRendererInfos[0].defaultMaterial = CreateMaterial("matMinecraftSword", StaticValues.maxSwordGlow, Color.white);
minecraftRendererInfos[1].defaultMaterial = CreateMaterial("matMinecraftPaladin", 3, Color.white);
SkinDef minecraftSkin = CreateSkinDef("PALADINBODY_MINECRAFT_SKIN_NAME", Assets.mainAssetBundle.LoadAsset <Sprite>("texMinecraftSkin"), minecraftRendererInfos, mainRenderer, model, "");
minecraftSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Assets.minecraftMesh,
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Assets.minecraftSwordMesh,
renderer = defaultRenderers[0].renderer
}
};
skinDefs.Add(minecraftSkin);
#endregion
skinController.skins = skinDefs.ToArray();
}
internal static void TemplarSurvivor()
{
Templar.myCharacter = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/ClayBruiserBody").InstantiateClone("Templar_Survivor", true, "C:\\Users\\Tymmey\\Desktop\\RoRStuff\\Templar\\Templar\\Survivor\\Templar\\Templar.cs", "TemplarSurvivor", 37);
Templar.myCharacter.GetComponent <ModelLocator>().modelBaseTransform.gameObject.transform.localScale = Vector3.one * 0.9f;
Templar.myCharacter.GetComponent <ModelLocator>().modelBaseTransform.gameObject.transform.Translate(new Vector3(0f, 1.6f, 0f));
foreach (KinematicCharacterMotor kinematicCharacterMotor in Templar.myCharacter.GetComponentsInChildren <KinematicCharacterMotor>())
{
kinematicCharacterMotor.SetCapsuleDimensions(kinematicCharacterMotor.Capsule.radius * 0.5f, kinematicCharacterMotor.Capsule.height * 0.5f, 0f);
}
Templar.myCharacter.GetComponent <CharacterBody>().aimOriginTransform.Translate(new Vector3(0f, 0f, 0f));
Templar.myCharacter.GetComponent <SetStateOnHurt>().canBeHitStunned = false;
Templar.myCharacter.tag = "Player";
Templar.characterDisplay = Templar.myCharacter.GetComponent <ModelLocator>().modelBaseTransform.gameObject.InstantiateClone("TemplarDisplay", true, "C:TemplarClean.cs", "RegisterLemurian", 153);
Templar.characterDisplay.transform.localScale = Vector3.one * 0.8f;
Templar.characterDisplay.AddComponent <Templar.TemplarMenuAnim>();
Templar.characterDisplay.AddComponent <NetworkIdentity>();
GameObject gameObject = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/Pot2Body");
MeshRenderer componentInChildren = gameObject.GetComponentInChildren <MeshRenderer>();
GameObject gameObject2 = componentInChildren.gameObject.InstantiateClone("VagabondHead", false, "C:Lemurian.cs", "RegisterLemurian", 679);
UnityEngine.Object.Destroy(gameObject2.GetComponent <HurtBoxGroup>());
UnityEngine.Object.Destroy(gameObject2.transform.GetComponentInChildren <HurtBox>());
UnityEngine.Object.Destroy(gameObject2.transform.GetChild(0).gameObject);
gameObject2.transform.parent = Templar.myCharacter.GetComponentInChildren <ChildLocator>().FindChild("Head");
gameObject2.transform.localScale = new Vector3(1f, 1f, 1.25f);
gameObject2.transform.localRotation = Quaternion.Euler(new Vector3(-90f, 0f, 0f));
gameObject2.transform.localPosition = new Vector3(0f, -0.24f, 0f);
MeshRenderer componentInChildren2 = gameObject2.GetComponentInChildren <MeshRenderer>();
CharacterModel.RendererInfo[] baseRendererInfos = Templar.myCharacter.GetComponentInChildren <CharacterModel>().baseRendererInfos;
CharacterModel.RendererInfo[] baseRendererInfos2 = new CharacterModel.RendererInfo[]
{
baseRendererInfos[0],
baseRendererInfos[1],
baseRendererInfos[2],
baseRendererInfos[3],
baseRendererInfos[4],
baseRendererInfos[5],
new CharacterModel.RendererInfo
{
defaultMaterial = componentInChildren.material,
renderer = componentInChildren2,
defaultShadowCastingMode = ShadowCastingMode.On,
ignoreOverlays = false
}
};
Templar.myCharacter.GetComponentInChildren <CharacterModel>().baseRendererInfos = baseRendererInfos2;
CharacterCameraParams TemplarCam = ScriptableObject.CreateInstance <CharacterCameraParams>();
TemplarCam.name = "TemplarCam";
TemplarCam.data.minPitch = -70f;
TemplarCam.data.maxPitch = 70f;
TemplarCam.data.wallCushion = 0.1f;
TemplarCam.data.pivotVerticalOffset = 0f;
TemplarCam.data.idealLocalCameraPos = new Vector3(-0.35f, 2f, -12f);
Templar.myCharacter.GetComponent <CameraTargetParams>().cameraParams = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/CrocoBody").GetComponent <CameraTargetParams>().cameraParams;
CharacterBody component = Templar.myCharacter.GetComponent <CharacterBody>();
component.portraitIcon = Assets.templarIcon;
component.SetSpreadBloom(0f, false);
component.spreadBloomCurve = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponent <CharacterBody>().spreadBloomCurve;
component.spreadBloomDecayTime = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponent <CharacterBody>().spreadBloomDecayTime;
component.name = "Templar_Survivor";
component.baseNameToken = "Templar_Survivor";
component.subtitleNameToken = "Templar_Subtitle";
component.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
component.baseMaxHealth = Templar.baseHealth.Value;
component.levelMaxHealth = Templar.healthGrowth.Value;
component.baseRegen = Templar.baseRegen.Value;
component.levelRegen = Templar.regenGrowth.Value;
component.baseDamage = Templar.baseDamage.Value;
component.levelDamage = Templar.damageGrowth.Value;
component.baseArmor = Templar.baseArmor.Value;
component.baseJumpPower = 15f;
component.baseCrit = 1f;
component.baseMoveSpeed = 7f;
component.autoCalculateLevelStats = true;
component._defaultCrosshairPrefab = LegacyResourcesAPI.Load <GameObject>("Prefabs/Crosshair/SimpleDotCrosshair");
component.preferredPodPrefab = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/CrocoBody").GetComponent <CharacterBody>().preferredPodPrefab;
component.levelMoveSpeed = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/LoaderBody").GetComponent <CharacterBody>().levelMoveSpeed;
component.sprintingSpeedMultiplier = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/LoaderBody").GetComponent <CharacterBody>().sprintingSpeedMultiplier;
component.GetComponent <CharacterMotor>().mass = LegacyResourcesAPI.Load <GameObject>("Prefabs/CharacterBodies/LoaderBody").GetComponentInChildren <CharacterMotor>().mass;
Templar.TemplarPrefab = Templar.myCharacter;
SurvivorDef survivorDef = ScriptableObject.CreateInstance <SurvivorDef>();
survivorDef.cachedName = "Templar_Survivor";
survivorDef.descriptionToken = "Templar_Description";
survivorDef.primaryColor = Templar.CHAR_COLOR;
survivorDef.bodyPrefab = Templar.TemplarPrefab;
survivorDef.displayPrefab = Templar.characterDisplay;
survivorDef.outroFlavorToken = "Templar_ENDING";
survivorDef.desiredSortPosition = 16f;
Loader.survivorDefs.Add(survivorDef);
Loader.bodyPrefabs.Add(Templar.myCharacter);
}
public void AddSkin(GameObject gameObject, string SkinFolder, ConfigFile config)
{
LoadoutAPI.SkinDefInfo skinDefInfo = new LoadoutAPI.SkinDefInfo();
skinDefInfo.BaseSkins = new SkinDef[0];
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(config.Bind <Color>("", "IconColorTop", Color.magenta).Value, config.Bind <Color>("", "IconColorRight", Color.black).Value, config.Bind <Color>("", "IconColorBottom", Color.magenta).Value, config.Bind <Color>("", "IconColorLeft", Color.black).Value);
skinDefInfo.NameToken = config.Bind <string>("", "SkinName", "DefaultName").Value;
skinDefInfo.UnlockableName = config.Bind <string>("", "UnlockableName", "").Value;
skinDefInfo.RootObject = gameObject.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
skinDefInfo.RendererInfos = new CharacterModel.RendererInfo[0];
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
skinDefInfo.GameObjectActivations = new SkinDef.GameObjectActivation[0];
skinDefInfo.Name = "CUSTOM_" + gameObject.name + "_SKIN";
base.Logger.LogInfo("Adding new skin to " + gameObject.name + " with name " + skinDefInfo.NameToken);
int MeshReplacementIndex = config.Bind <int>("", "MeshReplacementIndex", -1).Value;
string MeshReplacementKey = config.Bind <string>("", "SkinMeshToUse", "Default").Value;
string minionSkinForBody = config.Bind <string>("", "MinionReplacementForBody", "NONE", new ConfigDescription("If this is a minion skin, determines the characterbody for it")).Value;
string minionSkinForSkin = config.Bind <string>("", "MinionReplacementForSkin", "NONE", new ConfigDescription("If this is a minion skin, determines the characterbody for it")).Value;
bool isMinionSkin = false;
if (minionSkinForBody != null)
{
isMinionSkin = minionSkinForBody != "NONE";
}
if (MeshReplacementKey != "Default" && MeshReplacementKey != "Custom" && MeshReplacementKey != null)
{
SkinDef def1 = gameObject.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <ModelSkinController>().skins.First(x => x.nameToken == MeshReplacementKey);
MeshReplacementIndex = Array.IndexOf(gameObject.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <ModelSkinController>().skins, def1);
}
SkinDef def = gameObject.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <ModelSkinController>().skins[MeshReplacementIndex];
if (def)
{
skinDefInfo.MeshReplacements = def.meshReplacements;
skinDefInfo.RendererInfos = def.rendererInfos;
}
CharacterModel.RendererInfo[] rendererInfos = skinDefInfo.RendererInfos;
CharacterModel.RendererInfo[] array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
foreach (string MaterialFolder in Directory.EnumerateDirectories(SkinFolder))
{
//Get name of render from folder name
string[] MaterialIndexVs = MaterialFolder.Split(new string[] { @"\" }, StringSplitOptions.None);
string RendererName = MaterialIndexVs[MaterialIndexVs.Length - 1];
//Find the renderer based on the name
int index = Array.IndexOf(array, array.FirstOrDefault(x => x.renderer.name == RendererName));
//Get the material of the renderer
Material defaultMaterial = array[index].defaultMaterial;
if (defaultMaterial)
{
//Create a clone of the material
defaultMaterial = UnityEngine.Object.Instantiate <Material>(defaultMaterial);
//Iterate through all files related to this material from the skin folder
foreach (string FilePath in Directory.EnumerateFiles(MaterialFolder))
{
//Loading and applying textures from .png
if (FilePath.EndsWith(".PNG") || FilePath.EndsWith(".png"))
{
//Use File name to get texture name
string[] FilePathVs = FilePath.Split(new string[] { @"\" }, StringSplitOptions.None);
string FileName = FilePathVs[FilePathVs.Length - 1].Replace(".PNG", "");
//Create new Texture2d and load image in
Texture2D savedTex = new Texture2D(1, 1, TextureFormat.RGBAFloat, false, true);
ImageConversion.LoadImage(savedTex, System.IO.File.ReadAllBytes(FilePath));
//Apply the loaded image
savedTex.Apply();
//Attempt to place this image onto the material in the correct property
if (defaultMaterial.HasProperty(FileName))
{
defaultMaterial.enableInstancing = true;
defaultMaterial.SetTexture(FileName, GetReadableTextureCopy(savedTex));
}
}
else if (FilePath.EndsWith(".cfg"))
{
//Load the config at this path
BepInEx.Configuration.ConfigFile perMatConfig = new ConfigFile(FilePath, true);
//iterate through material properties and apply via config
foreach (string value in floatProperties)
{
if (defaultMaterial.HasProperty(value))
{
defaultMaterial.SetFloat(value, perMatConfig.Bind <float>("", value, defaultMaterial.GetFloat(value), new ConfigDescription("Sets the value for " + value)).Value);
}
}
foreach (string value in colorProperties)
{
if (defaultMaterial.HasProperty(value))
{
defaultMaterial.SetColor(value, perMatConfig.Bind <Color>("", value, defaultMaterial.GetColor(value), new ConfigDescription("Sets the value for " + value)).Value);
}
}
foreach (string value in defaultMaterial.shaderKeywords)
{
bool isEnabled = perMatConfig.Bind <bool>("", value, defaultMaterial.IsKeywordEnabled(value), new ConfigDescription("Sets the value for " + value)).Value;
if (isEnabled)
{
defaultMaterial.EnableKeyword(value);
}
else
{
defaultMaterial.DisableKeyword(value);
}
}
}
else
{
base.Logger.LogError("Unsupported file found in material folder: " + FilePath);
}
}
array[index].defaultMaterial = defaultMaterial;
}
}
skinDefInfo.RendererInfos = array;
LoadoutAPI.AddSkinToCharacter(gameObject, skinDefInfo);
SkinDef[] skins = gameObject.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <ModelSkinController>().skins;
skins[skins.Length - 1].minionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skins[skins.Length - 1].projectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
if (isMinionSkin)
{
base.Logger.LogInfo("Is a minion skin");
foreach (GameObject body in BodyCatalog.allBodyPrefabs)
{
if (body.name == minionSkinForBody)
{
base.Logger.LogInfo("Applying minionskinreplacement");
SkinDef defForMaster = body.GetComponentInChildren <ModelSkinController>().skins.First(x => x.nameToken == minionSkinForSkin);
base.Logger.LogInfo("Size was " + defForMaster.minionSkinReplacements.Length);
Array.Resize(ref defForMaster.minionSkinReplacements, defForMaster.minionSkinReplacements.Length + 1);
defForMaster.minionSkinReplacements[defForMaster.minionSkinReplacements.Length - 1] = new SkinDef.MinionSkinReplacement()
{
minionBodyPrefab = gameObject, minionSkin = skins[skins.Length - 1]
};
base.Logger.LogInfo("Size is now " + defForMaster.minionSkinReplacements.Length);
}
}
}
SkinDef[][] newSkins = typeof(BodyCatalog).GetFieldValue <SkinDef[][]>("skins");
newSkins[BodyCatalog.FindBodyIndex(gameObject)] = skins;
typeof(BodyCatalog).SetFieldValue <SkinDef[][]>("skins", newSkins);
}
public static void Create()
{
body = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody"), "UrsaBody", true);
NetworkIdentity networkIdentity = body.GetComponent <NetworkIdentity>();
networkIdentity.localPlayerAuthority = true;
GameObject model = CreateModel(body);
GameObject gameObject = new GameObject("ModelBase");
gameObject.transform.parent = body.transform;
gameObject.transform.localPosition = new Vector3(0f, -0.81f, 0f);
gameObject.transform.localRotation = Quaternion.identity;
gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
GameObject gameObject2 = new GameObject("CameraPivot");
gameObject2.transform.parent = gameObject.transform;
gameObject2.transform.localPosition = new Vector3(0f, 1.6f, 0f);
gameObject2.transform.localRotation = Quaternion.identity;
gameObject2.transform.localScale = Vector3.one;
GameObject gameObject3 = new GameObject("AimOrigin");
gameObject3.transform.parent = gameObject.transform;
gameObject3.transform.localPosition = new Vector3(0f, 1.4f, 0f);
gameObject3.transform.localRotation = Quaternion.identity;
gameObject3.transform.localScale = Vector3.one;
Transform transform = model.transform;
transform.parent = gameObject.transform;
transform.localPosition = Vector3.zero;
transform.localScale = new Vector3(1f, 1f, 1f);
transform.localRotation = Quaternion.identity;
CharacterDirection characterDirection = body.GetComponent <CharacterDirection>();
characterDirection.moveVector = Vector3.zero;
characterDirection.targetTransform = gameObject.transform;
characterDirection.overrideAnimatorForwardTransform = null;
characterDirection.rootMotionAccumulator = null;
characterDirection.modelAnimator = model.GetComponentInChildren <Animator>();
characterDirection.driveFromRootRotation = false;
characterDirection.turnSpeed = 720f;
CharacterBody bodyComponent = body.GetComponent <CharacterBody>();
bodyComponent.bodyIndex = BodyIndex.None;
bodyComponent.baseNameToken = "URSA_NAME";
bodyComponent.subtitleNameToken = "URSA_SUBTITLE";
bodyComponent.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
bodyComponent.rootMotionInMainState = false;
bodyComponent.mainRootSpeed = 0;
bodyComponent.baseMaxHealth = Core.Config.baseMaxHealth.Value;
bodyComponent.levelMaxHealth = Core.Config.levelMaxHealth.Value;
bodyComponent.baseRegen = Core.Config.baseRegen.Value;
bodyComponent.levelRegen = Core.Config.levelRegen.Value;
bodyComponent.baseMaxShield = Core.Config.baseMaxShield.Value;
bodyComponent.levelMaxShield = Core.Config.levelMaxShield.Value;
bodyComponent.baseMoveSpeed = Core.Config.baseMoveSpeed.Value;
bodyComponent.levelMoveSpeed = Core.Config.levelMoveSpeed.Value;
bodyComponent.baseAcceleration = Core.Config.baseAcceleration.Value;
bodyComponent.baseJumpPower = Core.Config.baseJumpPower.Value;
bodyComponent.levelJumpPower = Core.Config.levelJumpPower.Value;
bodyComponent.baseJumpCount = Core.Config.baseJumpCount.Value;
bodyComponent.baseDamage = Core.Config.baseDamage.Value;
bodyComponent.levelDamage = Core.Config.levelDamage.Value;
bodyComponent.baseAttackSpeed = Core.Config.baseAttackSpeed.Value;
bodyComponent.levelAttackSpeed = Core.Config.levelAttackSpeed.Value;
bodyComponent.baseCrit = Core.Config.baseCrit.Value;
bodyComponent.levelCrit = Core.Config.levelCrit.Value;
bodyComponent.baseArmor = Core.Config.baseArmor.Value;
bodyComponent.levelArmor = Core.Config.levelArmor.Value;
bodyComponent.sprintingSpeedMultiplier = Core.Config.sprintingSpeedMultiplier.Value;
bodyComponent.wasLucky = false;
bodyComponent.hideCrosshair = false;
bodyComponent.crosshairPrefab = Resources.Load <GameObject>("prefabs/crosshair/simpledotcrosshair");
bodyComponent.aimOriginTransform = gameObject3.transform;
bodyComponent.hullClassification = HullClassification.Human;
bodyComponent.portraitIcon = Core.Assets.portrait.texture;
bodyComponent.isChampion = false;
bodyComponent.currentVehicle = null;
bodyComponent.skinIndex = 0U;
LoadoutAPI.AddSkill(typeof(States.UrsaMain));
var stateMachine = body.GetComponent <EntityStateMachine>();
stateMachine.mainStateType = new SerializableEntityStateType(typeof(States.UrsaMain));
CharacterMotor characterMotor = body.GetComponent <CharacterMotor>();
characterMotor.walkSpeedPenaltyCoefficient = 1f;
characterMotor.characterDirection = characterDirection;
characterMotor.muteWalkMotion = false;
characterMotor.mass = 200f;
characterMotor.airControl = 0.25f;
characterMotor.disableAirControlUntilCollision = false;
characterMotor.generateParametersOnAwake = true;
//characterMotor.useGravity = true;
//characterMotor.isFlying = false;
InputBankTest inputBankTest = body.GetComponent <InputBankTest>();
inputBankTest.moveVector = Vector3.zero;
CameraTargetParams cameraTargetParams = body.GetComponent <CameraTargetParams>();
cameraTargetParams.cameraParams = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponent <CameraTargetParams>().cameraParams;
cameraTargetParams.cameraPivotTransform = null;
cameraTargetParams.aimMode = CameraTargetParams.AimType.Standard;
cameraTargetParams.recoil = Vector2.zero;
cameraTargetParams.idealLocalCameraPos = Vector3.zero;
cameraTargetParams.dontRaycastToPivot = false;
ModelLocator modelLocator = body.GetComponent <ModelLocator>();
modelLocator.modelTransform = transform;
modelLocator.modelBaseTransform = gameObject.transform;
modelLocator.dontReleaseModelOnDeath = false;
modelLocator.autoUpdateModelTransform = true;
modelLocator.dontDetatchFromParent = false;
modelLocator.noCorpse = false;
modelLocator.normalizeToFloor = true;
modelLocator.preserveModel = false;
ChildLocator childLocator = model.GetComponent <ChildLocator>();
HitBoxGroup rightClawHitBoxGroup = model.AddComponent <HitBoxGroup>();
HitBoxGroup leftClawHitBoxGroup = model.AddComponent <HitBoxGroup>();
GameObject rightClawGameObject = new GameObject("RightClawHitBox");
Transform rightClaw = childLocator.FindChild("R_Hand");
rightClawGameObject.transform.parent = rightClaw;
rightClawGameObject.transform.localPosition = new Vector3(-0.2f, 0.2f, 0.3f);
rightClawGameObject.transform.localScale = Vector3.one * 6.25f;
rightClawGameObject.transform.localRotation = Quaternion.identity;
HitBox rightClawHitBox = rightClawGameObject.AddComponent <HitBox>();
GameObject leftClawGameObject = new GameObject("LeftClawHitBox");
Transform leftClaw = childLocator.FindChild("L_Hand");
leftClawGameObject.transform.parent = leftClaw;
leftClawGameObject.transform.localPosition = new Vector3(-0.2f, 0.2f, 0.3f);
leftClawGameObject.transform.localScale = Vector3.one * 6.25f;
leftClawGameObject.transform.localRotation = Quaternion.identity;
HitBox leftClawHitBox = leftClawGameObject.AddComponent <HitBox>();
rightClawHitBoxGroup.hitBoxes = new HitBox[] { rightClawHitBox };
rightClawHitBoxGroup.groupName = "RightClaw";
leftClawHitBoxGroup.hitBoxes = new HitBox[] { leftClawHitBox };
leftClawHitBoxGroup.groupName = "LeftClaw";
Light rightLight = rightClaw.gameObject.AddComponent <Light>();
rightLight.type = LightType.Point;
rightLight.color = Color.yellow;
rightLight.range = 0.85f;
rightLight.intensity = 95f;
rightLight.enabled = false;
Light leftLight = leftClaw.gameObject.AddComponent <Light>();
leftLight.type = LightType.Point;
leftLight.color = Color.yellow;
leftLight.range = 0.85f;
leftLight.intensity = 95f;
leftLight.enabled = false;
CharacterModel characterModel = model.AddComponent <CharacterModel>();
characterModel.body = bodyComponent;
List <CharacterModel.RendererInfo> rendererInfos = new List <CharacterModel.RendererInfo>();
foreach (SkinnedMeshRenderer i in model.GetComponentsInChildren <SkinnedMeshRenderer>())
{
CharacterModel.RendererInfo info = new CharacterModel.RendererInfo
{
defaultMaterial = i.material,
renderer = i,
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = false
};
rendererInfos.Add(info);
}
characterModel.baseRendererInfos = rendererInfos.ToArray();
characterModel.autoPopulateLightInfos = true;
characterModel.invisibilityCount = 0;
characterModel.temporaryOverlays = new List <TemporaryOverlay>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
LoadoutAPI.SkinDefInfo skinDefInfo = new LoadoutAPI.SkinDefInfo
{
BaseSkins = Array.Empty <SkinDef>(),
GameObjectActivations = new SkinDef.GameObjectActivation[0],
Icon = Core.Assets.defaultSkinIcon,
MeshReplacements = new SkinDef.MeshReplacement[0],
MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0],
Name = "URSA_SKIN_DEFAULT_NAME",
NameToken = "URSA_SKIN_DEFAULT_NAME",
ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0],
RendererInfos = rendererInfos.ToArray(),
RootObject = model,
};
SkinDef skin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
skinController.skins = new SkinDef[] { skin };
TeamComponent teamComponent = null;
if (body.GetComponent <TeamComponent>() != null)
{
teamComponent = body.GetComponent <TeamComponent>();
}
else
{
teamComponent = body.GetComponent <TeamComponent>();
}
teamComponent.hideAllyCardDisplay = false;
teamComponent.teamIndex = TeamIndex.None;
HealthComponent healthComponent = body.GetComponent <HealthComponent>();
healthComponent.health = 90f;
healthComponent.shield = 0f;
healthComponent.barrier = 0f;
healthComponent.magnetiCharge = 0f;
healthComponent.body = null;
healthComponent.dontShowHealthbar = false;
healthComponent.globalDeathEventChanceCoefficient = 1f;
body.GetComponent <Interactor>().maxInteractionDistance = 3f;
body.GetComponent <InteractionDriver>().highlightInteractor = true;
CharacterDeathBehavior characterDeathBehavior = body.GetComponent <CharacterDeathBehavior>();
characterDeathBehavior.deathStateMachine = body.GetComponent <EntityStateMachine>();
characterDeathBehavior.deathState = new SerializableEntityStateType(typeof(GenericCharacterDeath));
SfxLocator sfxLocator = body.GetComponent <SfxLocator>();
sfxLocator.deathSound = "Play_ui_player_death";
sfxLocator.barkSound = "";
sfxLocator.openSound = "";
sfxLocator.landingSound = "Play_char_land";
sfxLocator.fallDamageSound = "Play_char_land_fall_damage";
sfxLocator.aliveLoopStart = "";
sfxLocator.aliveLoopStop = "";
Rigidbody rigidbody = body.GetComponent <Rigidbody>();
rigidbody.mass = 100f;
rigidbody.drag = 0f;
rigidbody.angularDrag = 0f;
rigidbody.useGravity = false;
rigidbody.isKinematic = true;
rigidbody.interpolation = RigidbodyInterpolation.None;
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidbody.constraints = RigidbodyConstraints.None;
CapsuleCollider capsuleCollider = body.GetComponent <CapsuleCollider>();
capsuleCollider.isTrigger = false;
capsuleCollider.material = null;
capsuleCollider.center = new Vector3(0f, 0f, 0f);
capsuleCollider.radius = 0.5f;
capsuleCollider.height = 1.82f;
capsuleCollider.direction = 1;
KinematicCharacterMotor kinematicCharacterMotor = body.GetComponent <KinematicCharacterMotor>();
kinematicCharacterMotor.CharacterController = characterMotor;
kinematicCharacterMotor.Capsule = capsuleCollider;
kinematicCharacterMotor.Rigidbody = rigidbody;
capsuleCollider.radius = 0.5f;
capsuleCollider.height = 1.82f;
capsuleCollider.center = new Vector3(0, 0, 0);
capsuleCollider.material = null;
kinematicCharacterMotor.DetectDiscreteCollisions = false;
kinematicCharacterMotor.GroundDetectionExtraDistance = 0f;
kinematicCharacterMotor.MaxStepHeight = 0.2f;
kinematicCharacterMotor.MinRequiredStepDepth = 0.1f;
kinematicCharacterMotor.MaxStableSlopeAngle = 55f;
kinematicCharacterMotor.MaxStableDistanceFromLedge = 0.5f;
kinematicCharacterMotor.PreventSnappingOnLedges = false;
kinematicCharacterMotor.MaxStableDenivelationAngle = 55f;
kinematicCharacterMotor.RigidbodyInteractionType = RigidbodyInteractionType.None;
kinematicCharacterMotor.PreserveAttachedRigidbodyMomentum = true;
kinematicCharacterMotor.HasPlanarConstraint = false;
kinematicCharacterMotor.PlanarConstraintAxis = Vector3.up;
kinematicCharacterMotor.StepHandling = StepHandlingMethod.None;
kinematicCharacterMotor.LedgeHandling = true;
kinematicCharacterMotor.InteractiveRigidbodyHandling = true;
kinematicCharacterMotor.SafeMovement = false;
HurtBoxGroup hurtBoxGroup = model.AddComponent <HurtBoxGroup>();
HurtBox componentInChildren = model.GetComponentInChildren <CapsuleCollider>().gameObject.AddComponent <HurtBox>();
componentInChildren.gameObject.layer = LayerIndex.entityPrecise.intVal;
componentInChildren.healthComponent = healthComponent;
componentInChildren.isBullseye = true;
componentInChildren.damageModifier = HurtBox.DamageModifier.Normal;
componentInChildren.hurtBoxGroup = hurtBoxGroup;
componentInChildren.indexInGroup = 0;
hurtBoxGroup.hurtBoxes = new HurtBox[]
{
componentInChildren
};
hurtBoxGroup.mainHurtBox = componentInChildren;
hurtBoxGroup.bullseyeCount = 1;
FootstepHandler footstepHandler = model.AddComponent <FootstepHandler>();
footstepHandler.baseFootstepString = "Play_player_footstep";
footstepHandler.sprintFootstepOverrideString = "";
footstepHandler.enableFootstepDust = true;
footstepHandler.footstepDustPrefab = Resources.Load <GameObject>("Prefabs/GenericFootstepDust");
RagdollController ragdollController = model.AddComponent <RagdollController>();
ragdollController.bones = null;
ragdollController.componentsToDisableOnRagdoll = null;
AimAnimator aimAnimator = model.AddComponent <AimAnimator>();
aimAnimator.inputBank = inputBankTest;
aimAnimator.directionComponent = characterDirection;
aimAnimator.pitchRangeMax = 55f;
aimAnimator.pitchRangeMin = -50f;
aimAnimator.yawRangeMin = -44f;
aimAnimator.yawRangeMax = 44f;
aimAnimator.pitchGiveupRange = 30f;
aimAnimator.yawGiveupRange = 10f;
aimAnimator.giveupDuration = 8f;
// Adds component used for keeping track of individual Ursa's Fury Swipes damage bonus from Enrage.
body.AddComponent <Miscellaneous.FurySwipesController>();
// Particle System that only emits when Overpower buff is active.
ParticleSystem.EmissionModule overpowerParticleSystemEmission = childLocator.FindChild("OverpowerParticles").GetComponent <ParticleSystem>().emission;
overpowerParticleSystemEmission.enabled = false;
//Doppelganger
doppelgangerMaster = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterMasters/CommandoMonsterMaster"), "UrsaDoppelGanger", true);
CharacterMaster component = doppelgangerMaster.GetComponent <CharacterMaster>();
component.bodyPrefab = body;
}
public static void RegisterSkins()
{
GameObject bodyPrefab = DiggerPlugin.characterPrefab;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = Reflection.GetFieldValue <SkinnedMeshRenderer>(characterModel, "mainSkinnedMeshRenderer");
GameObject diamondPickL = childLocator.FindChild("DiamondPickL").gameObject;
GameObject diamondPickR = childLocator.FindChild("DiamondPickR").gameObject;
GameObject[] allObjects = new GameObject[]
{
diamondPickL,
diamondPickR
};
LanguageAPI.Add("MINERBODY_DEFAULT_SKIN_NAME", "Default");
LanguageAPI.Add("MINERBODY_MOLTEN_SKIN_NAME", "Molten");
LanguageAPI.Add("MINERBODY_TYPHOON_SKIN_NAME", "Conqueror");
LanguageAPI.Add("MINERBODY_PUPLE_SKIN_NAME", "Puple");
LanguageAPI.Add("MINERBODY_TUNDRA_SKIN_NAME", "Tundra");
LanguageAPI.Add("MINERBODY_BLACKSMITH_SKIN_NAME", "Blacksmith");
LanguageAPI.Add("MINERBODY_IRON_SKIN_NAME", "Iron");
LanguageAPI.Add("MINERBODY_GOLD_SKIN_NAME", "Gold");
LanguageAPI.Add("MINERBODY_DIAMOND_SKIN_NAME", "Diamond");
LanguageAPI.Add("MINERBODY_STEVE_SKIN_NAME", "Minecraft");
LanguageAPI.Add("MINERBODY_DRIP_SKIN_NAME", "Drip");
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = Array.Empty <SkinDef>();
skinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
skinDefInfo.GameObjectActivations = getActivations(allObjects);
skinDefInfo.Icon = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponentInChildren <ModelSkinController>().skins[0].icon;
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
skinDefInfo.Name = "MINERBODY_DEFAULT_SKIN_NAME";
skinDefInfo.NameToken = "MINERBODY_DEFAULT_SKIN_NAME";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
CharacterModel.RendererInfo[] rendererInfos = skinDefInfo.RendererInfos;
CharacterModel.RendererInfo[] array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
Material commandoMat = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponentInChildren <CharacterModel>().baseRendererInfos[0].defaultMaterial;
//clone commando material for that spicy hopoo shader
Material material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(commandoMat);
material.SetColor("_Color", Color.white);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMiner").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMiner").GetTexture("_EmissionMap"));
material.SetFloat("_NormalStrength", 0);
//material.SetTexture("_NormalTex", Assets.mainAssetBundle.LoadAsset<Material>("matMiner").GetTexture("_BumpMap"));
array[0].defaultMaterial = material;
}
//and do the same for the diamond picks
material = array[1].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(commandoMat);
material.SetColor("_Color", Color.white);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matDiamondPick").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetFloat("_NormalStrength", 0);
array[1].defaultMaterial = material;
}
material = array[2].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(commandoMat);
material.SetColor("_Color", Color.white);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matDiamondPick").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetFloat("_NormalStrength", 0);
array[2].defaultMaterial = material;
}
skinDefInfo.RendererInfos = array;
#region Default
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
#endregion
#region Molten
LoadoutAPI.SkinDefInfo moltenSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
moltenSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
moltenSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
moltenSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
moltenSkinDefInfo.GameObjectActivations = getActivations(allObjects);
moltenSkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texMoltenAchievement");
moltenSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
moltenSkinDefInfo.Name = "MINERBODY_MOLTEN_SKIN_NAME";
moltenSkinDefInfo.NameToken = "MINERBODY_MOLTEN_SKIN_NAME";
moltenSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
moltenSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerMolten").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 5);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerMolten").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
moltenSkinDefInfo.RendererInfos = array;
SkinDef moltenSkin = LoadoutAPI.CreateNewSkinDef(moltenSkinDefInfo);
#endregion
#region Puple
LoadoutAPI.SkinDefInfo pupleSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
pupleSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
pupleSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
pupleSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
pupleSkinDefInfo.GameObjectActivations = getActivations(allObjects);
pupleSkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texPupleAchievement");
pupleSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
pupleSkinDefInfo.Name = "MINERBODY_PUPLE_SKIN_NAME";
pupleSkinDefInfo.NameToken = "MINERBODY_PUPLE_SKIN_NAME";
pupleSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
pupleSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerPuple").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 1);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerPuple").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
pupleSkinDefInfo.RendererInfos = array;
SkinDef pupleSkin = LoadoutAPI.CreateNewSkinDef(pupleSkinDefInfo);
#endregion
#region Tundra
LoadoutAPI.SkinDefInfo tundraSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
tundraSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
tundraSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
tundraSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
tundraSkinDefInfo.GameObjectActivations = getActivations(allObjects);
tundraSkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texTundraAchievement");
tundraSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = Assets.tundraMesh
}
};
tundraSkinDefInfo.Name = "MINERBODY_TUNDRA_SKIN_NAME";
tundraSkinDefInfo.NameToken = "MINERBODY_TUNDRA_SKIN_NAME";
tundraSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
tundraSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerTundra").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerTundra").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
tundraSkinDefInfo.RendererInfos = array;
SkinDef tundraSkin = LoadoutAPI.CreateNewSkinDef(tundraSkinDefInfo);
#endregion
#region GrandMastery
LoadoutAPI.SkinDefInfo grandMasterySkinDefInfo = default(LoadoutAPI.SkinDefInfo);
grandMasterySkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
grandMasterySkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
grandMasterySkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
grandMasterySkinDefInfo.GameObjectActivations = getActivations(allObjects);
grandMasterySkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texGrandMasteryAchievement");
grandMasterySkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = Assets.grandMasteryMesh
}
};
grandMasterySkinDefInfo.Name = "MINERBODY_TYPHOON_SKIN_NAME";
grandMasterySkinDefInfo.NameToken = "MINERBODY_TYPHOON_SKIN_NAME";
grandMasterySkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
grandMasterySkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerGM").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerGM").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
grandMasterySkinDefInfo.RendererInfos = array;
SkinDef grandMasterySkin = LoadoutAPI.CreateNewSkinDef(grandMasterySkinDefInfo);
#endregion
#region Iron
LoadoutAPI.SkinDefInfo ironSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
ironSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
ironSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
ironSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
ironSkinDefInfo.GameObjectActivations = getActivations(allObjects);
ironSkinDefInfo.Icon = Resources.Load <GameObject>("Prefabs/CharacterBodies/HuntressBody").GetComponentInChildren <ModelSkinController>().skins[1].icon;
ironSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
ironSkinDefInfo.Name = "MINERBODY_IRON_SKIN_NAME";
ironSkinDefInfo.NameToken = "MINERBODY_IRON_SKIN_NAME";
ironSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
ironSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerIron").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0);
array[0].defaultMaterial = material;
}
ironSkinDefInfo.RendererInfos = array;
SkinDef ironSkin = LoadoutAPI.CreateNewSkinDef(ironSkinDefInfo);
#endregion
#region Gold
LoadoutAPI.SkinDefInfo goldSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
goldSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
goldSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
goldSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
goldSkinDefInfo.GameObjectActivations = getActivations(allObjects);
goldSkinDefInfo.Icon = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponentInChildren <ModelSkinController>().skins[1].icon;
goldSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
goldSkinDefInfo.Name = "MINERBODY_GOLD_SKIN_NAME";
goldSkinDefInfo.NameToken = "MINERBODY_GOLD_SKIN_NAME";
goldSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
goldSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerGold").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerGold").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
goldSkinDefInfo.RendererInfos = array;
SkinDef goldSkin = LoadoutAPI.CreateNewSkinDef(goldSkinDefInfo);
#endregion
#region Diamond
LoadoutAPI.SkinDefInfo diamondSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
diamondSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
diamondSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
diamondSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
diamondSkinDefInfo.GameObjectActivations = getActivations(allObjects);
diamondSkinDefInfo.Icon = Resources.Load <GameObject>("Prefabs/CharacterBodies/MercBody").GetComponentInChildren <ModelSkinController>().skins[0].icon;
diamondSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
diamondSkinDefInfo.Name = "MINERBODY_DIAMOND_SKIN_NAME";
diamondSkinDefInfo.NameToken = "MINERBODY_DIAMOND_SKIN_NAME";
diamondSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
diamondSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerDiamond").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0.75f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerDiamond").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
diamondSkinDefInfo.RendererInfos = array;
SkinDef diamondSkin = LoadoutAPI.CreateNewSkinDef(diamondSkinDefInfo);
#endregion
#region Blacksmith
LoadoutAPI.SkinDefInfo blacksmithSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
blacksmithSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
blacksmithSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
blacksmithSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
blacksmithSkinDefInfo.GameObjectActivations = getActivations(allObjects);
blacksmithSkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texBlacksmithAchievement");
blacksmithSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = Assets.blacksmithMesh
}
};
blacksmithSkinDefInfo.Name = "MINERBODY_BLACKSMITH_SKIN_NAME";
blacksmithSkinDefInfo.NameToken = "MINERBODY_BLACKSMITH_SKIN_NAME";
blacksmithSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
blacksmithSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matBlacksmith").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matBlacksmith").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
blacksmithSkinDefInfo.RendererInfos = array;
SkinDef blacksmithSkin = LoadoutAPI.CreateNewSkinDef(blacksmithSkinDefInfo);
#endregion
#region Drip
LoadoutAPI.SkinDefInfo dripSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
dripSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
dripSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
dripSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
dripSkinDefInfo.GameObjectActivations = getActivations(allObjects);
dripSkinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texDripSkin");
dripSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = Assets.dripMesh
}
};
dripSkinDefInfo.Name = "MINERBODY_DRIP_SKIN_NAME";
dripSkinDefInfo.NameToken = "MINERBODY_DRIP_SKIN_NAME";
dripSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
dripSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matDripMiner").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matDripMiner").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
dripSkinDefInfo.RendererInfos = array;
SkinDef dripSkin = LoadoutAPI.CreateNewSkinDef(dripSkinDefInfo);
#endregion
#region Steve
LoadoutAPI.SkinDefInfo steveSkinDefInfo = default(LoadoutAPI.SkinDefInfo);
steveSkinDefInfo.BaseSkins = Array.Empty <SkinDef>();
steveSkinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
steveSkinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
steveSkinDefInfo.GameObjectActivations = getActivations(allObjects, diamondPickL, diamondPickR);
steveSkinDefInfo.Icon = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponentInChildren <ModelSkinController>().skins[0].icon;
steveSkinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = Assets.steveMesh
}
};
steveSkinDefInfo.Name = "MINERBODY_STEVE_SKIN_NAME";
steveSkinDefInfo.NameToken = "MINERBODY_STEVE_SKIN_NAME";
steveSkinDefInfo.RendererInfos = characterModel.baseRendererInfos;
steveSkinDefInfo.RootObject = model;
rendererInfos = skinDefInfo.RendererInfos;
array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
material = array[0].defaultMaterial;
if (material)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerSteve").GetTexture("_MainTex"));
material.SetColor("_EmColor", Color.white);
material.SetFloat("_EmPower", 0.75f);
material.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matMinerSteve").GetTexture("_EmissionMap"));
array[0].defaultMaterial = material;
}
steveSkinDefInfo.RendererInfos = array;
SkinDef steveSkin = LoadoutAPI.CreateNewSkinDef(steveSkinDefInfo);
#endregion
var skinDefs = new List <SkinDef>();
if (DiggerPlugin.starstormInstalled)
{
skinDefs = new List <SkinDef>()
{
defaultSkin,
moltenSkin,
grandMasterySkin,
tundraSkin,
pupleSkin,
blacksmithSkin
};
}
else
{
skinDefs = new List <SkinDef>()
{
defaultSkin,
moltenSkin,
tundraSkin,
pupleSkin,
blacksmithSkin
};
}
if (DiggerPlugin.extraSkins.Value)
{
skinDefs.Add(dripSkin);
skinDefs.Add(steveSkin);
skinDefs.Add(ironSkin);
skinDefs.Add(goldSkin);
skinDefs.Add(diamondSkin);
}
skinController.skins = skinDefs.ToArray();
}
public static void CreateDireseeker()
{
if (DiggerPlugin.direseekerInstalled)
{
AddUnlockComponent();
}
if (DiggerPlugin.fatAcrid.Value)
{
PerroGrande();
}
CreateProjectiles();
LanguageAPI.Add("DIRESEEKER_BODY_NAME", "Direseeker");
LanguageAPI.Add("DIRESEEKER_BODY_SUBTITLE", "Track and Kill");
//LanguageAPI.Add("DIRESEEKER_BODY_LORE", "Direseeker\n\nDireseeker is a giant Elder Lemurian that acts as a boss in the Stage 4 area Magma Barracks. Upon defeating it, the player will unlock the Miner character for future playthroughs. The path leading to Direseeker's location only appears in one of the three variants of the level, and even then Direseeker may or may not spawn with random chance. Completing the teleporter event will also prevent it from spawning.\nNote that in online co-op the boss may spawn for the Host, but not others, although they can still damage it.\nActivating the Artifact of Kin does not prevent it from appearing.\n\nCategories: Enemies | Bosses | Unlisted Enemies\n\nLanguages: Español");
LanguageAPI.Add("DIRESEEKER_BODY_LORE", "Legends tell of a monstrous beast that once roamed the underground barracks of Petrichor V.\n\nFeared by the bravest of survivors and the nastiest of monsters, the massive beast was unrivaled. It donned blood-red scales, tempered by hellfire. It had burning yellow eyes, with a glare so intense it made the largest of creatures stop dead in their tracks. It had smoldering breath, hot enough to melt metal in an instant.\n\nOnly once stopped by a survivor strong enough to slay Providence himself, it was believed that the beast had finally met its match.\n\n<style=cIsHealth>Until it showed its terrifying face once again.</style>");
LanguageAPI.Add("DIRESEEKER_BODY_OUTRO_FLAVOR", "..and so it left, in search of new prey.");
//skills and states
LoadoutAPI.AddSkill(typeof(EntityStates.Direseeker.SpawnState));
LoadoutAPI.AddSkill(typeof(EntityStates.Direseeker.ChargeUltraFireball));
LoadoutAPI.AddSkill(typeof(EntityStates.Direseeker.FireUltraFireball));
if (!DiggerPlugin.direseekerInstalled)
{
bodyPrefab = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterBodies/LemurianBruiserBody"), "DireseekerBody");
CharacterBody bodyComponent = bodyPrefab.GetComponent <CharacterBody>();
bodyComponent.name = "DireseekerBody";
bodyComponent.baseNameToken = "DIRESEEKER_BODY_NAME";
bodyComponent.subtitleNameToken = "DIRESEEKER_BODY_SUBTITLE";
bodyComponent.baseMoveSpeed = 11f;
bodyComponent.baseMaxHealth = 2800f;
bodyComponent.levelMaxHealth = 840f;
bodyComponent.baseDamage = 20f;
bodyComponent.levelDamage = 4f;
bodyComponent.isChampion = true;
bodyComponent.portraitIcon = Assets.mainAssetBundle.LoadAsset <Sprite>("texDireseekerIcon").texture;
SkillSetup(bodyPrefab);
var stateMachine = bodyComponent.GetComponentInChildren <EntityStateMachine>();
if (stateMachine)
{
stateMachine.initialStateType = new SerializableEntityStateType(typeof(EntityStates.Direseeker.SpawnState));
}
//resize
bodyPrefab.GetComponent <ModelLocator>().modelBaseTransform.gameObject.transform.localScale *= 1.5f;
//bodyPrefab.GetComponent<ModelLocator>().modelBaseTransform.gameObject.transform.Translate(new Vector3(0f, 5.6f, 0f));
foreach (KinematicCharacterMotor kinematicCharacterMotor in bodyPrefab.GetComponentsInChildren <KinematicCharacterMotor>())
{
kinematicCharacterMotor.SetCapsuleDimensions(kinematicCharacterMotor.Capsule.radius * 1.5f, kinematicCharacterMotor.Capsule.height * 1.5f, 1.5f);
}
//
CharacterModel model = bodyPrefab.GetComponentInChildren <CharacterModel>();
Material newMat = UnityEngine.Object.Instantiate <Material>(model.baseRendererInfos[0].defaultMaterial);
newMat.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matDireseeker").GetTexture("_MainTex"));
newMat.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matDireseeker").GetTexture("_EmissionMap"));
newMat.SetFloat("_EmPower", 50f);
model.baseRendererInfos[0].defaultMaterial = newMat;
GameObject horn1 = Assets.mainAssetBundle.LoadAsset <GameObject>("DireHorn").InstantiateClone("DireseekerHorn", false);
GameObject horn2 = Assets.mainAssetBundle.LoadAsset <GameObject>("DireHornBroken").InstantiateClone("DireseekerHornBroken", false);
//GameObject rageFlame = Assets.mainAssetBundle.LoadAsset<GameObject>("DireseekerRageFlame").InstantiateClone("DireseekerRageFlame", false);
GameObject burstFlame = Assets.mainAssetBundle.LoadAsset <GameObject>("DireseekerBurstFlame").InstantiateClone("DireseekerBurstFlame", false);
ChildLocator childLocator = bodyPrefab.GetComponentInChildren <ChildLocator>();
horn1.transform.SetParent(childLocator.FindChild("Head"));
horn1.transform.localPosition = new Vector3(-2.5f, 1, -0.5f);
horn1.transform.localRotation = Quaternion.Euler(new Vector3(45, 0, 90));
horn1.transform.localScale = new Vector3(100, 100, 100);
horn2.transform.SetParent(childLocator.FindChild("Head"));
horn2.transform.localPosition = new Vector3(2.5f, 1, -0.5f);
horn2.transform.localRotation = Quaternion.Euler(new Vector3(45, 0, 90));
horn2.transform.localScale = new Vector3(100, -100, 100);
/*rageFlame.transform.SetParent(childLocator.FindChild("Head"));
* rageFlame.transform.localPosition = new Vector3(0, 1, 0);
* rageFlame.transform.localRotation = Quaternion.Euler(new Vector3(270, 180, 0));
* rageFlame.transform.localScale = new Vector3(5, 5, 5);*/
burstFlame.transform.SetParent(childLocator.FindChild("Head"));
burstFlame.transform.localPosition = new Vector3(0, 1, 0);
burstFlame.transform.localRotation = Quaternion.Euler(new Vector3(270, 180, 0));
burstFlame.transform.localScale = new Vector3(5, 5, 5);
bodyPrefab.AddComponent <DireseekerController>().burstFlame = burstFlame.GetComponent <ParticleSystem>();
Shader hotpoo = Resources.Load <Shader>("Shaders/Deferred/hgstandard");
Material hornMat = horn1.GetComponentInChildren <MeshRenderer>().material;
hornMat.shader = hotpoo;
//add horns
CharacterModel.RendererInfo[] infos = model.baseRendererInfos;
CharacterModel.RendererInfo[] newInfos = new CharacterModel.RendererInfo[]
{
infos[0],
new CharacterModel.RendererInfo
{
renderer = horn1.GetComponentInChildren <MeshRenderer>(),
defaultMaterial = hornMat,
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = true
},
new CharacterModel.RendererInfo
{
renderer = horn2.GetComponentInChildren <MeshRenderer>(),
defaultMaterial = hornMat,
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = true
}
};
model.baseRendererInfos = newInfos;
masterPrefab = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterMasters/LemurianBruiserMaster"), "DireseekerMaster");
CharacterMaster master = masterPrefab.GetComponent <CharacterMaster>();
master.bodyPrefab = bodyPrefab;
master.isBoss = false;
DiggerPlugin.bodyPrefabs.Add(bodyPrefab);
DiggerPlugin.masterPrefabs.Add(masterPrefab);
if (DiggerPlugin.enableDireseeker.Value && !DiggerPlugin.direseekerInstalled)
{
CharacterSpawnCard characterSpawnCard = ScriptableObject.CreateInstance <CharacterSpawnCard>();
characterSpawnCard.name = "cscDireseeker";
characterSpawnCard.prefab = masterPrefab;
characterSpawnCard.sendOverNetwork = true;
characterSpawnCard.hullSize = HullClassification.BeetleQueen;
characterSpawnCard.nodeGraphType = MapNodeGroup.GraphType.Ground;
characterSpawnCard.requiredFlags = NodeFlags.None;
characterSpawnCard.forbiddenFlags = NodeFlags.TeleporterOK;
characterSpawnCard.directorCreditCost = 800;
characterSpawnCard.occupyPosition = false;
characterSpawnCard.loadout = new SerializableLoadout();
characterSpawnCard.noElites = true;
characterSpawnCard.forbiddenAsBoss = false;
DirectorCard card = new DirectorCard
{
spawnCard = characterSpawnCard,
selectionWeight = 1,
allowAmbushSpawn = false,
preventOverhead = false,
minimumStageCompletions = 2,
spawnDistance = DirectorCore.MonsterSpawnDistance.Close
};
DirectorAPI.DirectorCardHolder direseekerCard = new DirectorAPI.DirectorCardHolder
{
Card = card,
MonsterCategory = DirectorAPI.MonsterCategory.Champions,
InteractableCategory = DirectorAPI.InteractableCategory.None
};
DirectorAPI.MonsterActions += delegate(List <DirectorAPI.DirectorCardHolder> list, DirectorAPI.StageInfo stage)
{
if (stage.stage == DirectorAPI.Stage.AbyssalDepths)
{
if (!list.Contains(direseekerCard))
{
list.Add(direseekerCard);
}
}
};
}
}
if (DiggerPlugin.enableDireseekerSurvivor.Value)
{
survivorPrefab = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterBodies/LemurianBruiserBody"), "DireseekerPlayerBody");
CharacterBody bodyComponent2 = survivorPrefab.GetComponent <CharacterBody>();
bodyComponent2.name = "DireseekerPlayerBody";
bodyComponent2.baseNameToken = "DIRESEEKER_BODY_NAME";
bodyComponent2.subtitleNameToken = "DIRESEEKER_BODY_SUBTITLE";
bodyComponent2.baseMoveSpeed = 11f;
bodyComponent2.baseMaxHealth = 2200f;
bodyComponent2.levelMaxHealth = 800f;
bodyComponent2.baseRegen = 0.5f;
bodyComponent2.levelRegen = 0.2f;
bodyComponent2.baseDamage = 20f;
bodyComponent2.levelDamage = 4f;
bodyComponent2.isChampion = false;
bodyComponent2.portraitIcon = Assets.mainAssetBundle.LoadAsset <Sprite>("texDireseekerPlayerIcon").texture;
bodyComponent2.hideCrosshair = true;
SkillSetup(survivorPrefab);
var stateMachine = survivorPrefab.GetComponentInChildren <EntityStateMachine>();
if (stateMachine)
{
stateMachine.initialStateType = new SerializableEntityStateType(typeof(EntityStates.Direseeker.SpawnState));
}
//resize
survivorPrefab.GetComponent <ModelLocator>().modelBaseTransform.gameObject.transform.localScale *= 0.75f;
survivorPrefab.transform.GetChild(0).localPosition = new Vector3(0, -2.75f, 0);
survivorPrefab.transform.GetChild(2).localPosition = new Vector3(0, 0.8f, 1.5f);
foreach (KinematicCharacterMotor kinematicCharacterMotor in survivorPrefab.GetComponentsInChildren <KinematicCharacterMotor>())
{
kinematicCharacterMotor.SetCapsuleDimensions(kinematicCharacterMotor.Capsule.radius * 0.75f, kinematicCharacterMotor.Capsule.height * 0.75f, 0.75f);
}
//
CharacterModel model2 = survivorPrefab.GetComponentInChildren <CharacterModel>();
Material newMat = UnityEngine.Object.Instantiate <Material>(model2.baseRendererInfos[0].defaultMaterial);
newMat.SetTexture("_MainTex", Assets.mainAssetBundle.LoadAsset <Material>("matDireseeker").GetTexture("_MainTex"));
newMat.SetTexture("_EmTex", Assets.mainAssetBundle.LoadAsset <Material>("matDireseeker").GetTexture("_EmissionMap"));
newMat.SetFloat("_EmPower", 50f);
model2.baseRendererInfos[0].defaultMaterial = newMat;
GameObject horn1b = Assets.mainAssetBundle.LoadAsset <GameObject>("DireHorn").InstantiateClone("DireseekerHorn", false);
GameObject horn2b = Assets.mainAssetBundle.LoadAsset <GameObject>("DireHornBroken").InstantiateClone("DireseekerHornBroken", false);
//GameObject rageFlame = Assets.mainAssetBundle.LoadAsset<GameObject>("DireseekerRageFlame").InstantiateClone("DireseekerRageFlame", false);
GameObject burstFlame2 = Assets.mainAssetBundle.LoadAsset <GameObject>("DireseekerBurstFlame").InstantiateClone("DireseekerBurstFlame", false);
ChildLocator childLocator2 = survivorPrefab.GetComponentInChildren <ChildLocator>();
horn1b.transform.SetParent(childLocator2.FindChild("Head"));
horn1b.transform.localPosition = new Vector3(-2.5f, 1, -0.5f);
horn1b.transform.localRotation = Quaternion.Euler(new Vector3(45, 0, 90));
horn1b.transform.localScale = new Vector3(100, 100, 100);
horn2b.transform.SetParent(childLocator2.FindChild("Head"));
horn2b.transform.localPosition = new Vector3(2.5f, 1, -0.5f);
horn2b.transform.localRotation = Quaternion.Euler(new Vector3(45, 0, 90));
horn2b.transform.localScale = new Vector3(100, -100, 100);
/*rageFlame.transform.SetParent(childLocator.FindChild("Head"));
* rageFlame.transform.localPosition = new Vector3(0, 1, 0);
* rageFlame.transform.localRotation = Quaternion.Euler(new Vector3(270, 180, 0));
* rageFlame.transform.localScale = new Vector3(5, 5, 5);*/
burstFlame2.transform.SetParent(childLocator2.FindChild("Head"));
burstFlame2.transform.localPosition = new Vector3(0, 1, 0);
burstFlame2.transform.localRotation = Quaternion.Euler(new Vector3(270, 180, 0));
burstFlame2.transform.localScale = new Vector3(5, 5, 5);
survivorPrefab.AddComponent <DireseekerController>().burstFlame = burstFlame2.GetComponent <ParticleSystem>();
Shader hotpoo = Resources.Load <Shader>("Shaders/Deferred/hgstandard");
Material hornMat = horn1b.GetComponentInChildren <MeshRenderer>().material;
hornMat.shader = hotpoo;
//add horns
CharacterModel.RendererInfo[] infos2 = model2.baseRendererInfos;
CharacterModel.RendererInfo[] newInfos2 = new CharacterModel.RendererInfo[]
{
infos2[0],
new CharacterModel.RendererInfo
{
renderer = horn1b.GetComponentInChildren <MeshRenderer>(),
defaultMaterial = hornMat,
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = true
},
new CharacterModel.RendererInfo
{
renderer = horn2b.GetComponentInChildren <MeshRenderer>(),
defaultMaterial = hornMat,
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = true
}
};
model2.baseRendererInfos = newInfos2;
survivorPrefab.GetComponent <DeathRewards>().logUnlockableDef = null;
survivorPrefab.GetComponent <Interactor>().maxInteractionDistance = 5f;
survivorPrefab.tag = "Player";
SkinSetup();
DiggerPlugin.bodyPrefabs.Add(survivorPrefab);
GameObject displayPrefab = PrefabAPI.InstantiateClone(survivorPrefab.GetComponent <ModelLocator>().modelTransform.gameObject, "DireseekerDisplay", true);
displayPrefab.AddComponent <NetworkIdentity>();
displayPrefab.transform.localScale *= 0.5f;
SurvivorDef survivorDef = new SurvivorDef
{
displayNameToken = "DIRESEEKER_BODY_NAME",
descriptionToken = "MINER_DESCRIPTION",
primaryColor = Color.red,
bodyPrefab = survivorPrefab,
displayPrefab = displayPrefab,
outroFlavorToken = "DIRESEEKER_BODY_OUTRO_FLAVOR"
};
SurvivorAPI.AddSurvivor(survivorDef);
}
}
/// <summary>
/// Create a survivor prefab from a model. Don't register the prefab that it outputs, because the method already does that for you.
/// </summary>
/// <returns>The prefab created from the model.</returns>
public GameObject CreatePrefab()
{
if (prefabName == "")
{
Log.LogW("Prefab name has not been set.");
prefabName = "RandomAssSurvivorBody";
}
GameObject prefab = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody"), prefabName, true);
prefab.GetComponent <NetworkIdentity>().localPlayerAuthority = true;
SetupModelBase();
SetupCamera();
SetupAim();
void SetupModelBase()
{
UnityEngine.Object.Destroy(prefab.transform.Find("ModelBase").gameObject);
UnityEngine.Object.Destroy(prefab.transform.Find("CameraPivot").gameObject);
UnityEngine.Object.Destroy(prefab.transform.Find("AimOrigin").gameObject);
modelBase.transform.parent = prefab.transform;
modelBase.transform.localPosition = new Vector3(0f, -0.81f, 0f);
modelBase.transform.localRotation = Quaternion.identity;
//modelBase.transform.localScale = Vector3.one;
}
void SetupCamera()
{
camPivot.transform.parent = prefab.transform;
camPivot.transform.localPosition = new Vector3(0f, -0.81f, 0f);
camPivot.transform.rotation = Quaternion.identity;
camPivot.transform.localScale = Vector3.one;
}
void SetupAim()
{
aimOrigin.transform.parent = prefab.transform;
aimOrigin.transform.localPosition = new Vector3(0f, 1.4f, 0f);
aimOrigin.transform.rotation = Quaternion.identity;
aimOrigin.transform.localScale = Vector3.one;
}
if (!model)
{
Log.LogE("Character model has not been loaded, returning null. " + prefabName + " will not function properly.");
return(null);
}
Transform transform = model.transform;
CharacterDirection dir = prefab.GetComponent <CharacterDirection>();
CharacterBody body = prefab.GetComponent <CharacterBody>();
CharacterMotor motor = prefab.GetComponent <CharacterMotor>();
CameraTargetParams camParams = prefab.GetComponent <CameraTargetParams>();
ModelLocator locator = prefab.GetComponent <ModelLocator>();
CharacterModel charModel = transform.gameObject.AddComponent <CharacterModel>();
ChildLocator childLoc = model.GetComponent <ChildLocator>();
TeamComponent teamComponent = null;
if (prefab.GetComponent <TeamComponent>() != null)
{
teamComponent = prefab.GetComponent <TeamComponent>();
}
else
{
teamComponent = prefab.GetComponent <TeamComponent>();
}
HealthComponent health = prefab.GetComponent <HealthComponent>();
CharacterDeathBehavior deathBehavior = prefab.GetComponent <CharacterDeathBehavior>();
Rigidbody rigidbody = prefab.GetComponent <Rigidbody>();
CapsuleCollider collider = prefab.GetComponent <CapsuleCollider>();
KinematicCharacterMotor kMotor = prefab.GetComponent <KinematicCharacterMotor>();
HurtBoxGroup hurtbox = model.AddComponent <HurtBoxGroup>();
CapsuleCollider coll1 = model.GetComponentInChildren <CapsuleCollider>();
HurtBox hb = coll1.gameObject.AddComponent <HurtBox>();
FootstepHandler footstep = model.AddComponent <FootstepHandler>();
AimAnimator aimer = model.AddComponent <AimAnimator>();
SetupModelTransform();
SetupCharacterDirection();
SetupCharacterBody();
SetupCharacterMotor();
SetupCameraParams();
SetupModelLocator();
SetupModel();
SetupShaders();
SetupSkins();
SetupTeamComponent();
SetupHealthComponent();
SetupInteractors();
SetupDeathBehavior();
SetupRigidBody();
SetupCollider();
SetupKCharacterMotor();
SetupHurtbox();
SetupFootstep();
SetupAimAnimator();
SetupHitbox();
void SetupModelTransform()
{
transform.parent = modelBase.transform;
//transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
}
void SetupCharacterDirection()
{
dir.moveVector = Vector3.zero;
dir.targetTransform = modelBase.transform;
dir.overrideAnimatorForwardTransform = null;
dir.rootMotionAccumulator = null;
dir.modelAnimator = model.GetComponentInChildren <Animator>();
dir.driveFromRootRotation = false;
dir.turnSpeed = 720f;
}
void SetupCharacterBody()
{
body.name = prefabName;
body.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
body.rootMotionInMainState = false;
body.mainRootSpeed = 0;
body.bodyIndex = -1;
body.aimOriginTransform = aimOrigin.transform;
body.hullClassification = HullClassification.Human;
}
void SetupCharacterMotor()
{ //CharacterMotor motor = prefab.GetComponent<CharacterMotor>();
motor.walkSpeedPenaltyCoefficient = 1f;
motor.characterDirection = dir;
motor.muteWalkMotion = false;
motor.mass = 100f;
motor.airControl = 0.25f;
motor.disableAirControlUntilCollision = false;
motor.generateParametersOnAwake = true;
}
void SetupCameraParams()
{
camParams.cameraParams = Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponent <CameraTargetParams>().cameraParams;
camParams.cameraPivotTransform = null;
camParams.aimMode = CameraTargetParams.AimType.Standard;
camParams.recoil = Vector2.zero;
camParams.idealLocalCameraPos = Vector3.zero;
camParams.dontRaycastToPivot = false;
}
void SetupModelLocator()
{
locator.modelTransform = transform;
locator.modelBaseTransform = modelBase.transform;
locator.dontReleaseModelOnDeath = false;
locator.autoUpdateModelTransform = true;
locator.dontDetatchFromParent = false;
locator.noCorpse = false;
locator.normalizeToFloor = false;
locator.preserveModel = false;
}
void SetupTeamComponent()
{
teamComponent.hideAllyCardDisplay = false;
teamComponent.teamIndex = TeamIndex.None;
}
void SetupHealthComponent()
{
health.body = null;
health.dontShowHealthbar = false;
health.globalDeathEventChanceCoefficient = 1f;
}
void SetupInteractors()
{
prefab.GetComponent <Interactor>().maxInteractionDistance = 3f;
prefab.GetComponent <InteractionDriver>().highlightInteractor = true;
}
void SetupDeathBehavior()
{
deathBehavior.deathStateMachine = prefab.GetComponent <EntityStateMachine>();
deathBehavior.deathState = new SerializableEntityStateType(typeof(GenericCharacterDeath));
}
void SetupRigidBody()
{
rigidbody.mass = 100f;
rigidbody.drag = 0f;
rigidbody.angularDrag = 0f;
rigidbody.useGravity = false;
rigidbody.isKinematic = true;
rigidbody.interpolation = RigidbodyInterpolation.None;
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidbody.constraints = RigidbodyConstraints.None;
}
void SetupCollider()
{
collider.isTrigger = false;
collider.material = null;
collider.center = Vector3.zero;
collider.direction = 1;
}
void SetupModel()
{
charModel.body = body;
List <CharacterModel.RendererInfo> infos = new List <CharacterModel.RendererInfo>();
infos.Add(new CharacterModel.RendererInfo
{
defaultMaterial = model.GetComponentInChildren <SkinnedMeshRenderer>().material,
renderer = model.GetComponentInChildren <SkinnedMeshRenderer>(),
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off,
ignoreOverlays = false
});
SkinnedMeshRenderer[] skinnedMeshRenderer = model.GetComponentsInChildren <SkinnedMeshRenderer>();
for (int i = 0; i < skinnedMeshRenderer.Length; i++)
{
infos.Add(new CharacterModel.RendererInfo
{
defaultMaterial = skinnedMeshRenderer[i].material,
renderer = skinnedMeshRenderer[i],
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = false
});
}
charModel.baseRendererInfos = infos.ToArray();
charModel.autoPopulateLightInfos = true;
charModel.invisibilityCount = 0;
charModel.temporaryOverlays = new List <TemporaryOverlay>();
}
void SetupKCharacterMotor()
{
kMotor.CharacterController = motor;
kMotor.Capsule = collider;
kMotor.Rigidbody = rigidbody;
kMotor.DetectDiscreteCollisions = false;
kMotor.GroundDetectionExtraDistance = 0f;
kMotor.MaxStepHeight = 0.2f;
kMotor.MinRequiredStepDepth = 0.1f;
kMotor.MaxStableSlopeAngle = 55f;
kMotor.MaxStableDistanceFromLedge = 0.5f;
kMotor.PreventSnappingOnLedges = false;
kMotor.MaxStableDenivelationAngle = 55f;
kMotor.RigidbodyInteractionType = RigidbodyInteractionType.None;
kMotor.PreserveAttachedRigidbodyMomentum = true;
kMotor.HasPlanarConstraint = false;
kMotor.PlanarConstraintAxis = Vector3.up;
kMotor.StepHandling = StepHandlingMethod.None;
kMotor.LedgeHandling = true;
kMotor.InteractiveRigidbodyHandling = true;
kMotor.SafeMovement = false;
}
void SetupHurtbox()
{
hb.gameObject.layer = LayerIndex.entityPrecise.intVal;
hb.healthComponent = health;
hb.isBullseye = true;
hb.damageModifier = HurtBox.DamageModifier.Normal;
hb.hurtBoxGroup = hurtbox;
hb.indexInGroup = 0;
hurtbox.hurtBoxes = new HurtBox[] { hb };
hurtbox.mainHurtBox = hb;
hurtbox.bullseyeCount = 1;
}
void SetupFootstep()
{
footstep.baseFootstepString = "Play_player_footstep";
footstep.sprintFootstepOverrideString = "";
footstep.enableFootstepDust = true;
footstep.footstepDustPrefab = Resources.Load <GameObject>("Prefabs/GenericFootstepDust");
}
//RagdollController ragdoll = model.GetComponent<RagdollController>();
//TODO
//ragdoll.bones = null;
//ragdoll.componentsToDisableOnRagdoll = null;
void SetupAimAnimator()
{
aimer.inputBank = prefab.GetComponent <InputBankTest>();
aimer.directionComponent = dir;
aimer.pitchRangeMax = 60f;
aimer.pitchRangeMin = -60f;
aimer.yawRangeMax = 90f;
aimer.yawRangeMin = -90f;
aimer.pitchGiveupRange = 30f;
aimer.yawGiveupRange = 10f;
aimer.giveupDuration = 3f;
}
void SetupHitbox()
{
foreach (Transform child in transform)
{
if (child.name.Contains("Hitbox"))
{
var hitBoxGroup = model.AddComponent <HitBoxGroup>();
var hitBox = child.gameObject.AddComponent <HitBox>();
hitBoxGroup.groupName = child.name;
hitBoxGroup.hitBoxes = new HitBox[] { hitBox };
}
}
}
void SetupShaders()
{
foreach (Transform child in transform)
{
var renderer = child.gameObject.GetComponent <Renderer>();
if (renderer)
{
var material = CreateMaterial(renderer.material, 10, Color.white, 0);
renderer.material = material;
}
}
}
void SetupSkins()
{
//LanguageAPI.Add("NEMMANDO_DEFAULT_SKIN_NAME", "Default");
var obj = transform.gameObject;
var mdl = obj.GetComponent <CharacterModel>();
var skinController = obj.AddComponent <ModelSkinController>();
LoadoutAPI.SkinDefInfo skinDefInfo = new LoadoutAPI.SkinDefInfo
{
Name = "DEFAULT_SKIN",
NameToken = "DEFAULT_SKIN",
Icon = defaultSkinIcon,
RootObject = obj,
RendererInfos = mdl.baseRendererInfos,
GameObjectActivations = Array.Empty <SkinDef.GameObjectActivation>(),
MeshReplacements = Array.Empty <SkinDef.MeshReplacement>(),
BaseSkins = Array.Empty <SkinDef>(),
MinionSkinReplacements = Array.Empty <SkinDef.MinionSkinReplacement>(),
ProjectileGhostReplacements = Array.Empty <SkinDef.ProjectileGhostReplacement>(),
UnlockableName = ""
};
CharacterModel.RendererInfo[] rendererInfos = skinDefInfo.RendererInfos;
CharacterModel.RendererInfo[] array = new CharacterModel.RendererInfo[rendererInfos.Length];
rendererInfos.CopyTo(array, 0);
array[0].defaultMaterial = masterySkinDelegate.Invoke();
LoadoutAPI.SkinDefInfo masteryInfo = new LoadoutAPI.SkinDefInfo
{
Name = "DEFAULT_SKIN",
NameToken = "DEFAULT_SKIN",
Icon = defaultSkinIcon,
RootObject = obj,
RendererInfos = array,
GameObjectActivations = Array.Empty <SkinDef.GameObjectActivation>(),
MeshReplacements = Array.Empty <SkinDef.MeshReplacement>(),
BaseSkins = Array.Empty <SkinDef>(),
MinionSkinReplacements = Array.Empty <SkinDef.MinionSkinReplacement>(),
ProjectileGhostReplacements = Array.Empty <SkinDef.ProjectileGhostReplacement>(),
UnlockableName = masteryAchievementUnlockable
};
SkinDef skinDefault = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
SkinDef mastery = LoadoutAPI.CreateNewSkinDef(masteryInfo);
SkinDef[] skinDefs = new SkinDef[2]
{
skinDefault,
mastery
};
skinController.skins = skinDefs;
}
API.RegisterNewBody(prefab);
return(prefab);
}
