private static void InitializeNemSkins()
{
if (Prefabs.nemPaladinPrefab == null)
{
return;
}
GameObject bodyPrefab = Prefabs.nemPaladinPrefab;
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[0];
skinDefs.Add(defaultSkin);
#endregion
skinController.skins = skinDefs.ToArray();
}
private System.Xml.Linq.XElement BodyLoadout_ToXml(On.RoR2.Loadout.BodyLoadoutManager.BodyLoadout.orig_ToXml orig, System.Object self, String elementName)
{
Int32 bodyIndex = self.GetFieldValue <Int32>("bodyIndex");
ModelSkinController bodySkinController = BodyCatalog.GetBodyPrefab(bodyIndex).GetComponent <ModelLocator>().modelTransform.GetComponent <ModelSkinController>();
UInt32 skinPreference = self.GetFieldValue <UInt32>("skinPreference");
if (this.addedSkins.Contains(bodySkinController.skins[skinPreference]))
{
self.SetFieldValue <UInt32>("skinPreference", 0u);
}
UInt32[] skillPreferences = self.GetFieldValue <UInt32[]>("skillPreferences");
System.Object allBodyInfosObj = typeof(Loadout.BodyLoadoutManager).GetFieldValue <System.Object>("allBodyInfos");
System.Object[] allBodyInfos = ((Array)allBodyInfosObj).Cast <System.Object>().ToArray();
System.Object currentInfo = allBodyInfos[bodyIndex];
System.Object prefabSkillSlotsObj = currentInfo.GetFieldValue <System.Object>("prefabSkillSlots");
System.Object[] prefabSkillSlots = ((Array)prefabSkillSlotsObj).Cast <System.Object>().ToArray();
Int32[] skillFamilyIndices = currentInfo.GetFieldValue <Int32[]>("skillFamilyIndices");
for (Int32 i = 0; i < prefabSkillSlots.Length; i++)
{
Int32 skillFamilyIndex = skillFamilyIndices[i];
SkillFamily family = SkillCatalog.GetSkillFamily(skillFamilyIndex);
SkillDef def = family.variants[skillPreferences[i]].skillDef;
if (this.addedSkills.Contains(def))
{
skillPreferences[i] = 0u;
}
}
return(orig(self, elementName));
}
public static void RegisterSkins()
{
GameObject bodyPrefab = Prefabs.scoutPrefab;
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("SAXTONHALEBODY_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
}
private void Awake()
{
this.characterBody = this.GetComponent <CharacterBody>();
this.model = this.GetComponentInChildren <CharacterModel>();
this.skinController = this.GetComponentInChildren <ModelSkinController>();
this.isShiny = false;
this.Invoke("ShinyRoll", 0.1f);
this.Invoke("ApplyShiny", 0.2f);
}
private ModelSkinController AddDefaultSkin(GameObject def)
{
base.Logger.LogInfo("Adding default skin to " + def);
ModelSkinController component = def.GetComponentInChildren <ModelLocator>().modelTransform.gameObject.AddComponent <ModelSkinController>();
CharacterModel model = def.GetComponentInChildren <ModelLocator>().modelTransform.GetComponentInChildren <CharacterModel>();
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = new SkinDef[0];
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(Color.black, Color.white, Color.black, Color.white);
skinDefInfo.NameToken = "Default";
skinDefInfo.UnlockableName = "";
skinDefInfo.RootObject = def.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
skinDefInfo.RendererInfos = model.baseRendererInfos;
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
skinDefInfo.GameObjectActivations = new SkinDef.GameObjectActivation[1] {
new SkinDef.GameObjectActivation()
{
gameObject = def, shouldActivate = true
}
};
skinDefInfo.Name = "DEFAULT_" + def.name + "_SKIN";
if (model)
{
skinDefInfo.RendererInfos = model.baseRendererInfos;
for (int i = 0; i < skinDefInfo.RendererInfos.Length; i++)
{
skinDefInfo.RendererInfos[i].defaultMaterial.enableInstancing = true;
skinDefInfo.RendererInfos[i].renderer.material.enableInstancing = true;
skinDefInfo.RendererInfos[i].renderer.sharedMaterial.enableInstancing = true;
}
SkinDef skinDef3 = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
component.skins = new SkinDef[1] {
skinDef3
};
LoadoutAPI.AddSkinToCharacter(def, skinDef3);
SkinDef[] skins = component.skins;
SkinDef[][] newSkins = typeof(BodyCatalog).GetFieldValue <SkinDef[][]>("skins");
newSkins[BodyCatalog.FindBodyIndex(def)] = skins;
typeof(BodyCatalog).SetFieldValue <SkinDef[][]>("skins", newSkins);
}
else
{
base.Logger.LogError("Unable to create new skin for " + def);
}
return(component);
}
private void Awake()
{
// Get all relevant components;
this.characterBody = this.gameObject.GetComponent <CharacterBody>();
this.model = this.gameObject.GetComponentInChildren <CharacterModel>();
this.modelSkinController = this.gameObject.GetComponentInChildren <ModelSkinController>();
this.childLocator = this.gameObject.GetComponentInChildren <ChildLocator>();
this.skillLocator = this.gameObject.GetComponentInChildren <SkillLocator>();
this.modelLocator = this.gameObject.GetComponent <ModelLocator>();
this.jetStopwatch = new Stopwatch();
}
public void SelectSkin(int index)
{
if (!ModelSkinController)
{
return;
}
if (reverseSkin != null)
{
reverseSkin.Apply();
}
ModelSkinController.ApplySkin(index);
reverseSkin = new ReverseSkin(ModelInstance, ModelSkinController.skins[ModelSkinController.currentSkinIndex]);
}
public static void RegisterSkins()
{
GameObject bodyPrefab = GrovetenderPlugin.myCharacter;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
if (model.GetComponent <ModelSkinController>())
{
GrovetenderPlugin.Destroy(model.GetComponent <ModelSkinController>());
}
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = Reflection.GetFieldValue <SkinnedMeshRenderer>(characterModel, "mainSkinnedMeshRenderer");
LanguageAPI.Add("GROVETENDERBODY_DEFAULT_SKIN_NAME", "Default");
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = Array.Empty <SkinDef>();
skinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
skinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skinDefInfo.GameObjectActivations = Array.Empty <SkinDef.GameObjectActivation>();
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(new Color(0.09f, 0.03f, 0.03f), new Color(0.039f, 0.039f, 0.078f), new Color(0.61f, 0.59f, 0.5f), new Color(0.9f, 0.9f, 0.9f));
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
/*{
* new SkinDef.MeshReplacement
* {
* renderer = mainRenderer,
* mesh = mainRenderer.sharedMesh
* }
* };*/
skinDefInfo.Name = "GROVETENDERBODY_DEFAULT_SKIN_NAME";
skinDefInfo.NameToken = "GROVETENDERBODY_DEFAULT_SKIN_NAME";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
skinDefInfo.UnlockableName = "";
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
skinController.skins = new SkinDef[1]
{
defaultSkin
};
}
private static void SkinSetup()
{
GameObject model = survivorPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
if (model.GetComponent <ModelSkinController>())
{
DiggerPlugin.Destroy(model.GetComponent <ModelSkinController>());
}
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = Reflection.GetFieldValue <SkinnedMeshRenderer>(characterModel, "mainSkinnedMeshRenderer");
LanguageAPI.Add("DIRESEEKER_BODY_DEFAULT_SKIN_NAME", "Default");
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = Array.Empty <SkinDef>();
skinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
skinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skinDefInfo.GameObjectActivations = Array.Empty <SkinDef.GameObjectActivation>();
skinDefInfo.Icon = Assets.mainAssetBundle.LoadAsset <Sprite>("texMoltenAchievement");
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[0];
/*{
* new SkinDef.MeshReplacement
* {
* renderer = mainRenderer,
* mesh = mainRenderer.sharedMesh
* }
* };*/
skinDefInfo.Name = "DIRESEEKER_BODY_DEFAULT_SKIN_NAME";
skinDefInfo.NameToken = "DIRESEEKER_BODY_DEFAULT_SKIN_NAME";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
skinDefInfo.UnlockableName = "";
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
skinController.skins = new SkinDef[1]
{
defaultSkin
};
}
public void AddComponents(SurvivorDef def)
{
base.Logger.LogInfo("Add Components called on " + def.name);
ModelLocator modelLocator = def.bodyPrefab.GetComponent <ModelLocator>();
if (modelLocator)
{
ModelSkinController component = modelLocator.modelTransform.GetComponent <ModelSkinController>();
if (!component || component.skins.Length == 0)
{
component = AddDefaultSkin(def);
}
else
{
}
}
}
public void DefaultSetup(GameObject body)
{
ModelLocator modelLocator = body.GetComponentInChildren <ModelLocator>();
if (modelLocator)
{
ModelSkinController component = modelLocator.modelTransform.GetComponentInChildren <ModelSkinController>();
//If the character does not have a modelskincontroller, or no skins, add one with a default skin
if (!component || component.skins.Length == 0)
{
AddDefaultSkin(body);
}
}
else
{
base.Logger.LogError("ERROR: " + body.name + " Does not contain a model locator and cannot have skins.");
}
}
private static void CreateSkins()
{
GameObject model = characterPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = characterModel.mainSkinnedMeshRenderer;
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
List <SkinDef> skins = new List <SkinDef>();
#region DefaultSkin
SkinDef defaultSkin = Modules.Skins.CreateSkinDef(HenryPlugin.developerPrefix + "_HENRY_BODY_DEFAULT_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMainSkin"),
defaultRenderers,
mainRenderer,
model);
skins.Add(defaultSkin);
#endregion
#region MasterySkin
Material masteryMat = Modules.Assets.CreateMaterial("matHenryAlt");
CharacterModel.RendererInfo[] masteryRendererInfos = SkinRendererInfos(defaultRenderers, new Material[]
{
masteryMat,
masteryMat,
masteryMat
});
SkinDef masterySkin = Modules.Skins.CreateSkinDef(HenryPlugin.developerPrefix + "_HENRY_BODY_MASTERY_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievement"),
masteryRendererInfos,
mainRenderer,
model,
HenryPlugin.developerPrefix + "_HENRY_BODY_MASTERYUNLOCKABLE_REWARD_ID");
skins.Add(masterySkin);
#endregion
skinController.skins = skins.ToArray();
}
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();
}
public static Skin Create(CharacterModel character, params SkinDef[] baseSkins)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
GameObject root = character.gameObject;
if (root == null)
{
throw new ArgumentNullException(nameof(character));
}
ModelSkinController controller = root.AddOrGetComponent <ModelSkinController>();
if (controller == null)
{
throw new ArgumentNullException(nameof(character));
}
controller.skins ??= Array.Empty <SkinDef>();
HooksCore.RoR2.SkinDef.Awake.On += DoNothing;
SkinDef def = ScriptableObject.CreateInstance <SkinDef>();
HooksCore.RoR2.SkinDef.Awake.On -= DoNothing;
if (def == null)
{
throw new Exception("Failed to create SkinDef");
}
def.rootObject = root;
def.baseSkins = baseSkins;
if (baseSkins.Length == 0)
{
def.rendererInfos = character.baseRendererInfos.Clone() as CharacterModel.RendererInfo[];
}
return(new Skin(def, root, character, controller));
}
private static void InitializeSkins()
{
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
DestroyImmediate(model.GetComponent <ModelSkinController>());
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = characterModel.mainSkinnedMeshRenderer;
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
List <SkinDef> skins = new List <SkinDef>();
#region DefaultSkin
SkinDef defaultSkin = Modules.Skins.CreateSkinDef("Default",
Loadouts.CreateSkinIcon(new Color(0.8f, 0.8f, 0.8f), new Color(0.8f, 0.8f, 0.8f), new Color(0.8f, 0.8f, 0.8f), new Color(0.8f, 0.8f, 0.8f)),
defaultRenderers,
mainRenderer,
model);
skins.Add(defaultSkin);
#endregion
#region MasterySkin
SkinDef masterySkin = Modules.Skins.CreateSkinDef("Mastery",
Loadouts.CreateSkinIcon(new Color(0.15f, 0.15f, 0.15f), new Color(0.15f, 0.15f, 0.15f), new Color(0.15f, 0.15f, 0.15f), new Color(0.15f, 0.15f, 0.15f)),
defaultRenderers,
mainRenderer,
model);
skins.Add(masterySkin);
#endregion
skinController.skins = skins.ToArray();
}
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 Create()
{
stanWorshipperBody = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("prefabs/characterbodies/BanditBody"), "StanWorshipperBody", true);
stanWorshipperBody.GetComponent <NetworkIdentity>().localPlayerAuthority = true;
CharacterBody bodyComponent = stanWorshipperBody.GetComponent <CharacterBody>();
bodyComponent.bodyIndex = BodyIndex.None;
bodyComponent.baseNameToken = "STANWORSHIPPER_NAME";
bodyComponent.subtitleNameToken = "STANWORSHIPPER_SUBTITLE";
bodyComponent.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
bodyComponent.rootMotionInMainState = false;
bodyComponent.mainRootSpeed = 0;
bodyComponent.baseMaxHealth = 100;
bodyComponent.levelMaxHealth = 28;
bodyComponent.baseRegen = 0.5f;
bodyComponent.levelRegen = 0.25f;
bodyComponent.baseMaxShield = 0;
bodyComponent.levelMaxShield = 0;
bodyComponent.baseMoveSpeed = 7;
bodyComponent.levelMoveSpeed = 0;
bodyComponent.baseAcceleration = 80;
bodyComponent.baseJumpPower = 15;
bodyComponent.levelJumpPower = 0;
bodyComponent.baseDamage = 13;
bodyComponent.levelDamage = 3.3f;
bodyComponent.baseAttackSpeed = 1;
bodyComponent.levelAttackSpeed = 0;
bodyComponent.baseCrit = 1;
bodyComponent.levelCrit = 0;
bodyComponent.baseArmor = 5;
bodyComponent.levelArmor = 0;
bodyComponent.baseJumpCount = 1;
bodyComponent.sprintingSpeedMultiplier = 1.45f;
bodyComponent.wasLucky = false;
bodyComponent.hideCrosshair = false;
bodyComponent.hullClassification = HullClassification.Human;
bodyComponent.portraitIcon = Resources.Load <Texture>("textures/bodyicons/ScavBody");
bodyComponent.isChampion = false;
bodyComponent.currentVehicle = null;
bodyComponent.skinIndex = 0U;
bodyComponent.bodyColor = new Color(0.6f, 0.3f, 0f);
NetworkStateMachine networkStateMachine = stanWorshipperBody.GetComponent <NetworkStateMachine>();
EntityStateMachine customEntityStateMachine = stanWorshipperBody.AddComponent <EntityStateMachine>();
customEntityStateMachine.customName = "Sacrifice";
customEntityStateMachine.mainStateType = new SerializableEntityStateType(typeof(Idle));
customEntityStateMachine.initialStateType = new SerializableEntityStateType(typeof(Idle));
ArrayUtils.ArrayAppend(ref networkStateMachine.stateMachines, customEntityStateMachine);
//Adds a default placeholder skin to prevent weird errors (another disgusting waste of my time :D).
GameObject model = stanWorshipperBody.GetComponent <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
CharacterModel.RendererInfo[] renderInfos = characterModel.baseRendererInfos;
LoadoutAPI.SkinDefInfo skinDefInfo = new LoadoutAPI.SkinDefInfo
{
BaseSkins = Array.Empty <SkinDef>(),
GameObjectActivations = new SkinDef.GameObjectActivation[0],
Icon = Assets.emptyIcon,
MeshReplacements = new SkinDef.MeshReplacement[0],
MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0],
Name = "STANWORSHIPPER_NAME",
NameToken = "STANWORSHIPPER_NAME",
ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0],
RendererInfos = renderInfos,
RootObject = model
};
SkinDef skin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
skinController.skins = new SkinDef[] { skin };
//Doppelganger
stanWorshipperDoppelganger = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterMasters/CommandoMonsterMaster"), "StanWorshipperMonsterMaster", true);
if (!stanWorshipperDoppelganger.GetComponent <NetworkIdentity>())
{
stanWorshipperDoppelganger.AddComponent <NetworkIdentity>();
}
CharacterMaster component = stanWorshipperDoppelganger.GetComponent <CharacterMaster>();
component.bodyPrefab = stanWorshipperBody;
}
private void ModelSkinController_ApplySkin(On.RoR2.ModelSkinController.orig_ApplySkin orig, ModelSkinController self, int skinIndex)
{
orig(self, skinIndex);
CharacterModel model = self.GetComponent <CharacterModel>();
bool bandit1 = model.name == "mdlBandit";
bool bandit2 = model.name == "mdlBandit2";
Debug.LogWarning("kneeg");
if (bandit1 || bandit2)
{
Chat.AddMessage("<color=#fd2>The name's Doug Dimmadome,</color>");
DimmaBanditHatGrower hatGrower = model.GetComponent <ChildLocator>()
.FindChild("Head").GetChild(0).gameObject
.AddComponent <DimmaBanditHatGrower>()
.init(model, bandit1);
Chat.AddMessage("<color=#fd2>owner of the Dimmsdale dimmadome</color>");
}
}
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 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();
}
private void AddSkins(GameObject bodyObject) //credits to rob
{
GameObject bodyPrefab = bodyObject;
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = null;
if (model.GetComponent <ModelSkinController>())
{
skinController = model.GetComponent <ModelSkinController>();
}
else
{
skinController = model.AddComponent <ModelSkinController>();
}
SkinnedMeshRenderer mainRenderer = Reflection.GetFieldValue <SkinnedMeshRenderer>(characterModel, "mainSkinnedMeshRenderer");
if (mainRenderer == null)
{
CharacterModel.RendererInfo[] bRI = Reflection.GetFieldValue <CharacterModel.RendererInfo[]>(characterModel, "baseRendererInfos");
if (bRI != null)
{
foreach (CharacterModel.RendererInfo rendererInfo in bRI)
{
if (rendererInfo.renderer is SkinnedMeshRenderer)
{
mainRenderer = (SkinnedMeshRenderer)rendererInfo.renderer;
break;
}
}
if (mainRenderer != null)
{
characterModel.SetFieldValue <SkinnedMeshRenderer>("mainSkinnedMeshRenderer", mainRenderer);
}
}
}
LoadoutAPI.SkinDefInfo skinDefInfo = default(LoadoutAPI.SkinDefInfo);
skinDefInfo.BaseSkins = Array.Empty <SkinDef>();
skinDefInfo.GameObjectActivations = Array.Empty <SkinDef.GameObjectActivation>();
skinDefInfo.Icon = LoadoutAPI.CreateSkinIcon(Color.white, Color.white, Color.white, Color.white);
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
skinDefInfo.Name = "PYRO_DEFAULT_SKIN_NAME";
skinDefInfo.NameToken = "PYRO_DEFAULT_SKIN_NAME";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
skinDefInfo.UnlockableName = "";
skinDefInfo.MinionSkinReplacements = new SkinDef.MinionSkinReplacement[0];
skinDefInfo.ProjectileGhostReplacements = new SkinDef.ProjectileGhostReplacement[0];
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
skinController.skins = new SkinDef[1]
{
defaultSkin,
};
}
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 CreatePrefab()
{
SniperMain.sniperBodyPrefab = PrefabsCore.CreatePrefab("Sniper", true);
SniperMain.sniperBodyPrefab.tag = "Finish";
GameObject obj = SniperMain.sniperBodyPrefab;
NetworkIdentity netId = obj.AddOrGetComponent <NetworkIdentity>();
netId.localPlayerAuthority = true;
var modelBase = new GameObject("ModelBase");
modelBase.transform.parent = obj.transform;
modelBase.transform.localPosition = new Vector3(0f, -0.81f, 0f);
modelBase.transform.localRotation = Quaternion.identity;
modelBase.transform.localScale = new Vector3(1f, 1f, 1f);
var cameraPivot = new GameObject("CameraPivot");
cameraPivot.transform.parent = modelBase.transform;
cameraPivot.transform.localPosition = new Vector3(0f, 1.6f, 0f);
cameraPivot.transform.localRotation = Quaternion.identity;
cameraPivot.transform.localScale = Vector3.one;
var aimOrigin = new GameObject("AimOrigin");
aimOrigin.transform.parent = modelBase.transform;
aimOrigin.transform.localPosition = new Vector3(0f, 1.4f, 0f);
aimOrigin.transform.localRotation = Quaternion.identity;
aimOrigin.transform.localScale = Vector3.one;
GameObject model = ModelModule.GetModel();
Transform modelTransform = model.transform;
modelTransform.parent = modelBase.transform;
modelTransform.localPosition = Vector3.zero;
modelTransform.localScale = Vector3.one;
modelTransform.localRotation = Quaternion.identity;
CharacterDirection direction = obj.AddOrGetComponent <CharacterDirection>();
direction.moveVector = Vector3.zero;
direction.targetTransform = modelBase.transform;
direction.overrideAnimatorForwardTransform = null;
direction.rootMotionAccumulator = null;
direction.modelAnimator = null;
direction.driveFromRootRotation = false;
direction.turnSpeed = 720f;
//CharacterBody borkBorkBody = null;
//if(borkBorkBody is null) return;
//borkBorkBody.baseMaxHealth = 150f;
//borkBorkBody.baseMoveSpeed = 9f;
//borkBorkBody.baseJumpPower = 20f;
//borkBorkBody.baseDamage = 12f;
SniperCharacterBody body = obj.AddOrGetComponent <SniperCharacterBody>();
body.bodyIndex = (BodyIndex)(-1);
body.baseNameToken = Tokens.SNIPER_NAME;
body.subtitleNameToken = Tokens.SNIPER_SUBTITLE;
body.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
body.rootMotionInMainState = false;
body.mainRootSpeed = 0f;
body.baseMaxHealth = 130f;
body.levelMaxHealth = 39f;
body.baseRegen = 2f;
body.levelRegen = 0.4f;
body.baseMaxShield = 0f;
body.levelMaxShield = 0f;
body.baseMoveSpeed = 7f;
body.levelMoveSpeed = 0f;
body.baseAcceleration = 60f;
body.baseJumpPower = 15f;
body.levelJumpPower = 0f;
body.baseDamage = 12f;
body.levelDamage = 3.6f;
body.baseAttackSpeed = 1f;
body.levelAttackSpeed = 0f;
body.baseCrit = 1f;
body.levelCrit = 0f;
body.baseArmor = 0f;
body.levelArmor = 0f;
body.baseJumpCount = 1;
body.sprintingSpeedMultiplier = 1.45f;
body.wasLucky = false;
body.spreadBloomDecayTime = 1f;
body.spreadBloomCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
body.crosshairPrefab = UIModule.GetCrosshair();
body.hideCrosshair = false;
body.aimOriginTransform = aimOrigin.transform;
body.hullClassification = HullClassification.Human;
body.portraitIcon = UIModule.GetPortraitIcon();
body.isChampion = false;
body.currentVehicle = null;
body.preferredPodPrefab = MiscModule.GetPodPrefab();
body.preferredInitialStateType = SkillsCore.StateType <Uninitialized>();
body.skinIndex = 0u;
CharacterMotor motor = obj.AddOrGetComponent <CharacterMotor>();
motor.walkSpeedPenaltyCoefficient = 1f;
motor.characterDirection = direction;
motor.muteWalkMotion = false;
motor.mass = 100f;
motor.airControl = 0.25f;
motor.disableAirControlUntilCollision = false;
motor.generateParametersOnAwake = true;
motor.useGravity = true;
motor.isFlying = false;
InputBankTest input = obj.AddOrGetComponent <InputBankTest>();
input.moveVector = Vector3.zero;
CameraTargetParams ctp = obj.AddOrGetComponent <CameraTargetParams>();
ctp.cameraParams = MiscModule.GetCharCameraParams();
ctp.cameraPivotTransform = null;
ctp.aimMode = CameraTargetParams.AimType.Standard;
ctp.recoil = Vector2.zero;
ctp.idealLocalCameraPos = Vector3.zero;
ctp.dontRaycastToPivot = false;
ModelLocator modelLocator = obj.AddOrGetComponent <ModelLocator>();
modelLocator.modelTransform = modelTransform;
modelLocator.modelBaseTransform = modelBase.transform;
modelLocator.dontReleaseModelOnDeath = false;
modelLocator.autoUpdateModelTransform = true;
modelLocator.dontDetatchFromParent = false;
modelLocator.noCorpse = false;
modelLocator.normalizeToFloor = false;
modelLocator.preserveModel = false;
EntityStateMachine bodyMachine = obj.AddOrGetComponent <EntityStateMachine>();
bodyMachine.customName = "Body";
bodyMachine.initialStateType = SkillsCore.StateType <SpawnTeleporterState>();
bodyMachine.mainStateType = SkillsCore.StateType <GenericCharacterMain>();
EntityStateMachine weaponMachine = obj.AddComponent <EntityStateMachine>();
weaponMachine.customName = "Weapon";
weaponMachine.initialStateType = SkillsCore.StateType <Idle>();
weaponMachine.mainStateType = SkillsCore.StateType <Idle>();
EntityStateMachine scopeMachine = obj.AddComponent <EntityStateMachine>();
scopeMachine.customName = "Scope";
scopeMachine.initialStateType = SkillsCore.StateType <Idle>();
scopeMachine.mainStateType = SkillsCore.StateType <Idle>();
EntityStateMachine reloadMachine = obj.AddComponent <EntityStateMachine>();
reloadMachine.customName = "Reload";
reloadMachine.initialStateType = SkillsCore.StateType <Idle>();
reloadMachine.mainStateType = SkillsCore.StateType <Idle>();
EntityStateMachine[] allStateMachines = new[] { bodyMachine, weaponMachine, scopeMachine, reloadMachine };
EntityStateMachine[] nonBodyStateMachines = new[] { weaponMachine, scopeMachine, reloadMachine };
GenericSkill ammoSkill = obj.AddOrGetComponent <GenericSkill>();
ammoSkill._skillFamily = SkillFamiliesModule.GetAmmoSkillFamily();
HooksModule.AddReturnoverride(ammoSkill);
//GenericSkill passiveSkill = obj.AddComponent<GenericSkill>();
//passiveSkill._skillFamily = SkillFamiliesModule.GetPassiveSkillFamily();
//HooksModule.AddReturnoverride( passiveSkill );
GenericSkill primarySkill = obj.AddComponent <GenericSkill>();
primarySkill._skillFamily = SkillFamiliesModule.GetPrimarySkillFamily();
GenericSkill secondarySkill = obj.AddComponent <GenericSkill>();
secondarySkill._skillFamily = SkillFamiliesModule.GetSecondarySkillFamily();
GenericSkill utilitySkill = obj.AddComponent <GenericSkill>();
utilitySkill._skillFamily = SkillFamiliesModule.GetUtilitySkillFamily();
GenericSkill specialSkill = obj.AddComponent <GenericSkill>();
specialSkill._skillFamily = SkillFamiliesModule.GetSpecialSkillFamily();
SkillLocator skillLocator = obj.AddOrGetComponent <SkillLocator>();
skillLocator.primary = primarySkill;
skillLocator.secondary = secondarySkill;
skillLocator.utility = utilitySkill;
skillLocator.special = specialSkill;
skillLocator.passiveSkill = new SkillLocator.PassiveSkill
{
enabled = false,
icon = null,
skillDescriptionToken = null,
skillNameToken = null,
};
TeamComponent team = obj.AddOrGetComponent <TeamComponent>();
team.hideAllyCardDisplay = false;
team.teamIndex = TeamIndex.None;
HealthComponent health = obj.AddOrGetComponent <HealthComponent>();
health.health = 100;
health.shield = 0;
health.barrier = 0;
health.magnetiCharge = 0;
health.body = null;
health.dontShowHealthbar = false;
health.globalDeathEventChanceCoefficient = 1f;
Interactor interactor = obj.AddOrGetComponent <Interactor>();
interactor.maxInteractionDistance = 3f;
InteractionDriver interaction = obj.AddOrGetComponent <InteractionDriver>();
interaction.highlightInteractor = true;
CharacterDeathBehavior death = obj.AddOrGetComponent <CharacterDeathBehavior>();
death.deathStateMachine = bodyMachine;
death.deathState = SkillsCore.StateType <EntityStates.Commando.DeathState>();
death.idleStateMachine = nonBodyStateMachines;
CharacterNetworkTransform netTrans = obj.AddOrGetComponent <CharacterNetworkTransform>();
netTrans.positionTransmitInterval = 0.05f;
netTrans.lastPositionTransmitTime = Single.MinValue;
netTrans.interpolationFactor = 3f;
netTrans.debugDuplicatePositions = false;
netTrans.debugSnapshotReceived = false;
NetworkStateMachine netStates = obj.AddOrGetComponent <NetworkStateMachine>();
netStates.stateMachines = allStateMachines;
//stateMachines.Set( netStates, allStateMachines );
CharacterEmoteDefinitions emotes = obj.AddOrGetComponent <CharacterEmoteDefinitions>();
emotes.emoteDefinitions = null;
EquipmentSlot equip = obj.AddOrGetComponent <EquipmentSlot>();
SfxLocator sfx = obj.AddOrGetComponent <SfxLocator>();
sfx.deathSound = "Play_ui_player_death";
sfx.barkSound = "";
sfx.openSound = "";
sfx.landingSound = "Play_char_land";
sfx.fallDamageSound = "Play_char_land_fall_damage";
sfx.aliveLoopStart = "";
sfx.aliveLoopStop = "";
Rigidbody rb = obj.AddOrGetComponent <Rigidbody>();
rb.mass = 100f;
rb.drag = 0f;
rb.angularDrag = 0f;
rb.useGravity = false;
rb.isKinematic = true;
rb.interpolation = RigidbodyInterpolation.None;
rb.collisionDetectionMode = CollisionDetectionMode.Discrete;
rb.constraints = RigidbodyConstraints.None;
CapsuleCollider col = obj.AddOrGetComponent <CapsuleCollider>();
col.isTrigger = false;
col.material = null;
col.center = new Vector3(0f, 0f, 0f);
col.radius = 0.5f;
col.height = 1.82f;
col.direction = 1;
KinematicCharacterMotor kinCharMot = obj.AddOrGetComponent <KinematicCharacterMotor>();
kinCharMot.CharacterController = motor;
kinCharMot.Capsule = col;
kinCharMot.Rigidbody = rb;
kinCharMot.CapsuleRadius = 0.5f;
kinCharMot.CapsuleHeight = 1.82f;
kinCharMot.CapsuleYOffset = 0f;
kinCharMot.CapsulePhysicsMaterial = null;
kinCharMot.DetectDiscreteCollisions = false;
kinCharMot.GroundDetectionExtraDistance = 0f;
kinCharMot.MaxStepHeight = 0.2f;
kinCharMot.MinRequiredStepDepth = 0.1f;
kinCharMot.MaxStableSlopeAngle = 55f;
kinCharMot.MaxStableDistanceFromLedge = 0.5f;
kinCharMot.PreventSnappingOnLedges = false;
kinCharMot.MaxStableDenivelationAngle = 55f;
kinCharMot.RigidbodyInteractionType = RigidbodyInteractionType.None;
kinCharMot.PreserveAttachedRigidbodyMomentum = true;
kinCharMot.HasPlanarConstraint = false;
kinCharMot.PlanarConstraintAxis = Vector3.up;
kinCharMot.StepHandling = StepHandlingMethod.None;
kinCharMot.LedgeHandling = true;
kinCharMot.InteractiveRigidbodyHandling = true;
kinCharMot.SafeMovement = false;
SetStateOnHurt hurt = obj.AddOrGetComponent <SetStateOnHurt>();
hurt.hitThreshold = 5f;
hurt.targetStateMachine = bodyMachine;
hurt.idleStateMachine = nonBodyStateMachines;
hurt.hurtState = SkillsCore.StateType <Idle>();
hurt.canBeHitStunned = false;
hurt.canBeStunned = false;
hurt.canBeFrozen = true;
CharacterModel charModel = model.AddOrGetComponent <CharacterModel>();
charModel.body = body;
charModel.itemDisplayRuleSet = ItemDisplayModule.GetSniperItemDisplay(model.AddOrGetComponent <ChildLocator>());
HurtBoxGroup hurtBoxGroup = model.AddOrGetComponent <HurtBoxGroup>();
HurtBox tempHb = model.GetComponentInChildren <HurtBox>();
tempHb.gameObject.layer = LayerIndex.entityPrecise.intVal;
tempHb.healthComponent = health;
tempHb.isBullseye = true;
tempHb.damageModifier = HurtBox.DamageModifier.Normal;
tempHb.hurtBoxGroup = hurtBoxGroup;
tempHb.indexInGroup = 0;
hurtBoxGroup.hurtBoxes = new[]
{
tempHb,
};
hurtBoxGroup.mainHurtBox = tempHb;
hurtBoxGroup.bullseyeCount = 1;
FootstepHandler footsteps = model.AddComponent <FootstepHandler>();
footsteps.baseFootstepString = "Play_player_footstep";
footsteps.sprintFootstepOverrideString = "";
footsteps.enableFootstepDust = true;
footsteps.footstepDustPrefab = UnityEngine.Resources.Load <GameObject>("Prefabs/GenericFootstepDust");
RagdollController ragdoll = model.AddOrGetComponent <RagdollController>();
ragdoll.bones = null; // FUTURE: Setup sniper ragdoll controller
ragdoll.componentsToDisableOnRagdoll = null;
AimAnimator aimAnimator = model.AddOrGetComponent <AimAnimator>();
aimAnimator.inputBank = input;
aimAnimator.directionComponent = direction;
aimAnimator.pitchRangeMax = 55f;
aimAnimator.pitchRangeMin = -50f;
aimAnimator.yawRangeMin = -40f;
aimAnimator.yawRangeMax = 45f;
aimAnimator.pitchGiveupRange = 30f;
aimAnimator.yawGiveupRange = 10f;
aimAnimator.giveupDuration = 8f;
ModelSkinController skinController = model.AddOrGetComponent <ModelSkinController>();
SkinDef[] skinsArray = skinController.skins;
for (Int32 i = 0; i < skinsArray.Length; ++i)
{
SkinDef skin = skinsArray[i];
skin.minionSkinReplacements = new[]
{
new SkinDef.MinionSkinReplacement
{
minionBodyPrefab = DecoyModule.GetDecoyPrefab(),
minionSkin = skin
},
};
}
foreach (IRuntimePrefabComponent comp in obj.GetComponents <IRuntimePrefabComponent>())
{
comp.InitializePrefab();
}
}
internal override void InitializeSkins()
{
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;
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
List <SkinDef> skins = new List <SkinDef>();
#region DefaultSkin
SkinDef defaultSkin = Modules.Skins.CreateSkinDef(HenryPlugin.developerPrefix + "_HENRY_BODY_DEFAULT_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMainSkin"),
defaultRenderers,
mainRenderer,
model);
defaultSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenrySword"),
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenryGun"),
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenry"),
renderer = defaultRenderers[instance.mainRendererIndex].renderer
}
};
skins.Add(defaultSkin);
#endregion
#region MasterySkin
Material masteryMat = Modules.Assets.CreateMaterial("matHenryAlt");
CharacterModel.RendererInfo[] masteryRendererInfos = SkinRendererInfos(defaultRenderers, new Material[]
{
masteryMat,
masteryMat
});
SkinDef masterySkin = Modules.Skins.CreateSkinDef(HenryPlugin.developerPrefix + "_HENRY_BODY_MASTERY_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievement"),
masteryRendererInfos,
mainRenderer,
model,
masterySkinUnlockableDef);
masterySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenrySwordAlt"),
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenryAlt"),
renderer = defaultRenderers[instance.mainRendererIndex].renderer
}
};
skins.Add(masterySkin);
#endregion
skinController.skins = skins.ToArray();
}
internal static void CreatePrefab()
{
// first clone the commando prefab so we can turn that into our own survivor
characterPrefab = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterBodies/CommandoBody"), "WispPreview", true, "C:\\Users\\test\\Documents\\ror2mods\\ExampleSurvivor\\ExampleSurvivor\\ExampleSurvivor\\ExampleSurvivor.cs", "CreatePrefab", 151);
//Debug.Log("Loaded prefab");
characterPrefab.GetComponent <NetworkIdentity>().localPlayerAuthority = true;
//Debug.Log("Set local player authority");
#region charactermodel
// create the model here, we're gonna replace commando's model with our own
GameObject model = CreateModel(characterPrefab);
GameObject gameObject = new GameObject("ModelBase");
gameObject.transform.parent = characterPrefab.transform;
gameObject.transform.localPosition = new Vector3(0f, -0.81f, 0f);
gameObject.transform.localRotation = Quaternion.identity;
gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
//Debug.Log("Created model base");
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;
//Debug.Log("Created camera pivot");
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;
//Debug.Log("Created aim origin");
Transform transform = model.transform;
transform.parent = gameObject.transform;
transform.localPosition = Vector3.zero;
transform.localScale = new Vector3(1f, 1f, 1f);
transform.localRotation = Quaternion.identity;
//Debug.Log("Created character transform");
CharacterDirection characterDirection = characterPrefab.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;
//Debug.Log("Set character direction");
#endregion
#region basestats
// set up the character body here
CharacterBody bodyComponent = characterPrefab.GetComponent <CharacterBody>();
bodyComponent.bodyIndex = -1;
bodyComponent.baseNameToken = "WISP_NAME"; // name token
bodyComponent.subtitleNameToken = "WISP_SUBTITLE"; // subtitle token- used for umbras
bodyComponent.bodyFlags = CharacterBody.BodyFlags.ImmuneToExecutes;
bodyComponent.rootMotionInMainState = false;
bodyComponent.mainRootSpeed = 0;
bodyComponent.baseMaxHealth = 82.5f;
bodyComponent.levelMaxHealth = 24.75f;
bodyComponent.baseRegen = 1f;
bodyComponent.levelRegen = 0.25f;
bodyComponent.baseMaxShield = 0;
bodyComponent.levelMaxShield = 0f;
bodyComponent.baseMoveSpeed = 7;
bodyComponent.levelMoveSpeed = 0;
bodyComponent.baseAcceleration = 80;
bodyComponent.baseJumpPower = 15;
bodyComponent.levelJumpPower = 0;
bodyComponent.baseDamage = 6;
bodyComponent.levelDamage = 1.2f;
bodyComponent.baseAttackSpeed = 1;
bodyComponent.levelAttackSpeed = 0;
bodyComponent.baseCrit = 1;
bodyComponent.levelCrit = 0;
bodyComponent.baseArmor = 0;
bodyComponent.levelArmor = 0;
bodyComponent.baseJumpCount = 1;
bodyComponent.sprintingSpeedMultiplier = 1.45f;
bodyComponent.wasLucky = false;
bodyComponent.hideCrosshair = false;
bodyComponent.aimOriginTransform = gameObject3.transform;
bodyComponent.hullClassification = HullClassification.Human;
bodyComponent.portraitIcon = Assets.charPortrait;
bodyComponent.isChampion = false;
bodyComponent.currentVehicle = null;
bodyComponent.skinIndex = 0U;
//Debug.Log("Created character body");
#endregion
#region spawning-and-states
//Replace the existing spawn animation
EntityStateMachine entityStateMachine = characterPrefab.GetComponent <EntityStateMachine>();
entityStateMachine.initialStateType = new SerializableEntityStateType(typeof(EntityStates.WispSurvivorStates.Spawn));
bodyComponent.currentVehicle = null;
bodyComponent.preferredPodPrefab = null;
bodyComponent.preferredInitialStateType = entityStateMachine.initialStateType;
//Change our main state to account for the float functionality
entityStateMachine.mainStateType = new SerializableEntityStateType(typeof(EntityStates.WispSurvivorStates.WispCharacterMain));
characterPrefab.AddComponent <TetherHandler>();
#endregion
#region movement-camera
// the charactermotor controls the survivor's movement and stuff
CharacterMotor characterMotor = characterPrefab.GetComponent <CharacterMotor>();
characterMotor.walkSpeedPenaltyCoefficient = 1f;
characterMotor.characterDirection = characterDirection;
characterMotor.muteWalkMotion = false;
characterMotor.mass = 100f;
//characterMotor.airControl = 0.75f;
characterMotor.airControl = 5f;
characterMotor.disableAirControlUntilCollision = false;
characterMotor.generateParametersOnAwake = true;
//characterMotor.useGravity = true;
//characterMotor.isFlying = false;
//Debug.Log("Created character motor");
InputBankTest inputBankTest = characterPrefab.GetComponent <InputBankTest>();
inputBankTest.moveVector = Vector3.zero;
CameraTargetParams cameraTargetParams = characterPrefab.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;
//Debug.Log("Created camera target parameters");
// this component is used to locate the character model(duh), important to set this up here
ModelLocator modelLocator = characterPrefab.GetComponent <ModelLocator>();
modelLocator.modelTransform = transform;
modelLocator.modelBaseTransform = gameObject.transform;
modelLocator.dontReleaseModelOnDeath = false;
modelLocator.autoUpdateModelTransform = true;
modelLocator.dontDetatchFromParent = false;
modelLocator.noCorpse = false;
modelLocator.normalizeToFloor = false; // set true if you want your character to rotate on terrain like acrid does
modelLocator.preserveModel = false;
//Debug.Log("Created model locator");
#endregion
// childlocator is something that must be set up in the unity project, it's used to find any child objects for things like footsteps or muzzle flashes
// also important to set up if you want quality
ChildLocator childLocator = model.GetComponent <ChildLocator>();
//Debug.Log("Established child locator reference");
// this component is used to handle all overlays and whatever on your character, without setting this up you won't get any cool effects like burning or freeze on the character
// it goes on the model object of course
CharacterModel characterModel = model.AddComponent <CharacterModel>();
characterModel.body = bodyComponent;
characterModel.baseRendererInfos = new CharacterModel.RendererInfo[]
{
// set up multiple rendererinfos if needed, but for this example there's only the one
new CharacterModel.RendererInfo
{
defaultMaterial = model.GetComponentInChildren <SkinnedMeshRenderer>().material,
renderer = model.GetComponentInChildren <SkinnedMeshRenderer>(),
defaultShadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On,
ignoreOverlays = true //Disable overlays for incorrectly formatted character
}
};
characterModel.autoPopulateLightInfos = true;
characterModel.invisibilityCount = 0;
characterModel.temporaryOverlays = new List <TemporaryOverlay>();
//Debug.Log("Created character model");
#region skin
SkinnedMeshRenderer mainRenderer = (characterModel.baseRendererInfos[0].renderer as SkinnedMeshRenderer);
if (!mainRenderer)
{
Debug.LogError("No main renderer found!");
}
if (!mainRenderer.sharedMesh)
{
Debug.LogError("No shared mesh found for main renderer!");
}
ModelSkinController modelSkinController = model.AddComponent <ModelSkinController>();
LanguageAPI.Add("WISP_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];
GameObject[] allObjects = new GameObject[0];
skinDefInfo.GameObjectActivations = getActivations(allObjects);
skinDefInfo.Icon = Assets.skin;
skinDefInfo.MeshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
renderer = mainRenderer,
mesh = mainRenderer.sharedMesh
}
};
skinDefInfo.Name = "WISP_DEFAULT_SKIN";
skinDefInfo.NameToken = "WISP_DEFAULT_SKIN";
skinDefInfo.RendererInfos = characterModel.baseRendererInfos;
skinDefInfo.RootObject = model;
skinDefInfo.UnlockableName = "";
SkinDef defaultSkin = LoadoutAPI.CreateNewSkinDef(skinDefInfo);
var skinDefs = new List <SkinDef>()
{
defaultSkin
};
modelSkinController.skins = skinDefs.ToArray();
//Debug.Log("Created skin");
#endregion
#region team-health
TeamComponent teamComponent = null;
if (characterPrefab.GetComponent <TeamComponent>() != null)
{
teamComponent = characterPrefab.GetComponent <TeamComponent>();
}
else
{
teamComponent = characterPrefab.GetComponent <TeamComponent>();
}
teamComponent.hideAllyCardDisplay = false;
teamComponent.teamIndex = TeamIndex.None;
HealthComponent healthComponent = characterPrefab.GetComponent <HealthComponent>();
healthComponent.health = 82.5f;
healthComponent.shield = 0f;
healthComponent.barrier = 0f;
healthComponent.magnetiCharge = 0f;
healthComponent.body = null;
healthComponent.dontShowHealthbar = false;
healthComponent.globalDeathEventChanceCoefficient = 1f;
//Debug.Log("Created components");
#endregion
characterPrefab.GetComponent <Interactor>().maxInteractionDistance = 3f;
characterPrefab.GetComponent <InteractionDriver>().highlightInteractor = true;
// this disables ragdoll since the character's not set up for it, and instead plays a death animation
CharacterDeathBehavior characterDeathBehavior = characterPrefab.GetComponent <CharacterDeathBehavior>();
characterDeathBehavior.deathStateMachine = characterPrefab.GetComponent <EntityStateMachine>();
characterDeathBehavior.deathState = new SerializableEntityStateType(typeof(GenericCharacterDeath));
// edit the sfxlocator if you want different sounds
SfxLocator sfxLocator = characterPrefab.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 = "";
//Debug.Log("Created sfx");
Rigidbody rigidbody = characterPrefab.GetComponent <Rigidbody>();
rigidbody.mass = 50f;
rigidbody.drag = 0f;
rigidbody.angularDrag = 0f;
rigidbody.useGravity = false;
rigidbody.isKinematic = true;
rigidbody.interpolation = RigidbodyInterpolation.None;
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidbody.constraints = RigidbodyConstraints.None;
//Debug.Log("Created rigidbody");
CapsuleCollider capsuleCollider = characterPrefab.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;
//Debug.Log("Created capsule collider");
KinematicCharacterMotor kinematicCharacterMotor = characterPrefab.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;
//Debug.Log("Set physics");
// this sets up the character's hurtbox, kinda confusing, but should be fine as long as it's set up in unity right
HurtBoxGroup hurtBoxGroup = model.AddComponent <HurtBoxGroup>();
//Debug.Log("Set reference to hurtBoxGroup");
if (model.GetComponentInChildren <CapsuleCollider>() == null)
{
Debug.LogError("Could not find capsule collider!");
}
HurtBox componentInChildren = model.GetComponentInChildren <CapsuleCollider>().gameObject.AddComponent <HurtBox>();
//Debug.Log("Added hurtbox component to capsule collider");
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;
//Debug.Log("Set components");
// this is for handling footsteps, not needed but polish is always good
FootstepHandler footstepHandler = model.AddComponent <FootstepHandler>();
footstepHandler.baseFootstepString = "Play_player_footstep";
footstepHandler.sprintFootstepOverrideString = "";
footstepHandler.enableFootstepDust = true;
footstepHandler.footstepDustPrefab = Assets.footstepPrefab;
// ragdoll controller is a pain to set up so we won't be doing that here..
RagdollController ragdollController = model.AddComponent <RagdollController>();
ragdollController.bones = null;
ragdollController.componentsToDisableOnRagdoll = null;
// this handles the pitch and yaw animations, but honestly they are nasty and a huge pain to set up so i didn't bother
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;
//Debug.Log("Finished setup");
}
