Time for an update!

It's been awhile since my last update. My project was quite dead during all of this time mostly because lack of time and programming skills.
Now is time to resurrect this project and start to write posts again and rewrite old systems.

I replaced Unity's default input system with Rewired which made input coding a bliss.

I modified Mixamo's paladin character to fit my needs.

Paladin only had diffuse, normal and specular textures which I needed to convert to more PBR friendly shape. Substance Painter proved to be perfect for this job. I wanted to get this done quick so
I started by adding old diffuse as a fill layer in subtance painter.
Then I added metal material as a fill layer and masked out every non-metal surfaces and added some leather material to all leather straps. Quick and results good enough for my tests.

Original diffuse

Metal and leather materials added.

Then I needed to chop this paladin into different body parts and add some kind of flesh material which I painted in Substance Painter.

All different body parts separated

I made a Warrior Creator script which makes making new warriors simple. I just need to make sure that every character rig and body parts follow my naming policy.
It used to be really long and time consuming process to prepare new character meshes as warrior but now it's just a one button. I could share it but it's so specific for my project so it would be quite pointless to share it.

I rewrote whole arm controller because old one was not that well coded, really shows my lack of experience as a coder.

I used Custom Handles to make it easy to adjust arm rotation limits in unity Scene view. Custom Handles is really nice asset if you need to make any kind of custom gizmos.

Anyways, here is the new LimbHandler and LimbHandlerInspector which should be more shareable than my earlier one.
There is some dependencies which I'll also share but I can't obviously share Rewired or Custom Handles.

	using UnityEngine;
	using Rewired;
	using System.Collections;
	using System;
	namespace Fleshwound.Core
	{
	public class LimbHandler : MonoBehaviour
	{
	public LimbAction[] Actions;
	//These three are used for the custom scene view gizmos
	[HideInInspector]
	public float AngleLimitX;
	[HideInInspector]
	public float AngleLimitY;
	[HideInInspector]
	public float AngleLimitZ;
	Vector4 newTransforms;
	Vector4 transformLimits = Vector4.zero;
	float rotation1 = 0F;
	float rotation2 = 0F;
	float rotation3 = 0F;
	float distanceValue;
	Quaternion originalRotation;
	Quaternion _quaternionX;
	Quaternion _quaternionY;
	Quaternion _quaternionZ;
	private bool Left;
	private bool Right;
	private Player player;
	public int PlayerID = 0;
	void Awake()
	{
	player = ReInput.players.GetPlayer(PlayerID);
	}
	private void Start()
	{
	newTransforms = Vector3.zero;
	distanceValue = 0f;
	originalRotation = transform.localRotation;
	_quaternionX = originalRotation;
	_quaternionY = originalRotation;
	_quaternionZ = originalRotation;
	//This is just to set correct location for distance movement if needed.
	foreach (var item in Actions)
	{
	if (item.MyTransformtype == Commons.TransformType.Move)
	switch (item.MoveVariables.MyMoveAxis)
	{
	case Commons.MoveAxis.X:
	newTransforms.w = transform.localPosition.x;
	break;
	case Commons.MoveAxis.Y:
	newTransforms.w = transform.localPosition.y;
	break;
	case Commons.MoveAxis.Z:
	newTransforms.w = transform.localPosition.z;
	break;
	default:
	break;
	}
	}
	}
	void Update()
	{
	//We are checking which hand is active for this player
	if (InputManager.Instance.GetRightHand(player))
	ToggleHand(Commons.Hand.Right);
	if (InputManager.Instance.GetLeftHand(player))
	ToggleHand(Commons.Hand.Left);
	if (InputManager.Instance.GetBothHand(player))
	ToggleHand(Commons.Hand.Left, true);
	//set transform values to 0 at beginning of every frame
	rotation1 = 0f;
	rotation2 = 0f;
	rotation3 = 0f;
	distanceValue = 0f;
	//for each action, if action is enabled check action handiness and active hand.
	foreach (LimbAction action in Actions)
	{
	if (action.Enabled)
	{
	if ((action.MyHand == Commons.Hand.Right && Right)
	||
	(action.MyHand == Commons.Hand.Left && Left)
	||
	(action.MyHand == Commons.Hand.None && (!Right && !Left)))
	{
	CheckInput(action);
	}
	}
	}
	}
	//check for actual input
	public void CheckInput(LimbAction action)
	{
	foreach (var MyActionButton in action.MyActionButton)
	{
	if (InputManager.Instance.GetAction1(player) && (MyActionButton == Commons.ActionButtons.ActionButton1))
	{
	AdjustTransform(action);
	}
	else if (InputManager.Instance.GetAction2(player) && (MyActionButton == Commons.ActionButtons.ActionButton2))
	{
	AdjustTransform(action);
	}
	else if (InputManager.Instance.GetAction3(player) && (MyActionButton == Commons.ActionButtons.ActionButton3))
	{
	AdjustTransform(action);
	}
	else if (!InputManager.Instance.GetAction1(player) && !InputManager.Instance.GetAction2(player) && !InputManager.Instance.GetAction3(player) && MyActionButton == Commons.ActionButtons.None)
	{
	AdjustTransform(action);
	}
	}
	}
	//adjust transform according to action
	public void AdjustTransform(LimbAction action)
	{
	//check if the action is rotation action
	bool isRotation = action.MyTransformtype == Commons.TransformType.Rotate ? true : false;
	//which axis is used to activate this action
	switch (action.MyInputType)
	{
	case Commons.InputType.Yaw:
	float yaw = InputManager.Instance.GetYaw(player);
	if (isRotation)
	{
	newTransforms.x += yaw * action.Sensitivity;
	newTransforms.x = ClampAngle(newTransforms.x, action);
	if (action.MySpace == Space.World)
	_quaternionX = Quaternion.AngleAxis(newTransforms.x, Vector3.up);
	else
	_quaternionX = Quaternion.AngleAxis(newTransforms.x, transform.up);
	//transform.localRotation = originalRotation * _quaternionX;
	}
	else
	{
	newTransforms.w += yaw * (action.Sensitivity / 20);
	newTransforms.w = ClampFloat(newTransforms.w, action);
	}
	break;
	case Commons.InputType.Pitch:
	float pitch = InputManager.Instance.GetPitch(player);
	if (isRotation)
	{
	newTransforms.y += pitch * action.Sensitivity;
	newTransforms.y = ClampAngle(newTransforms.y, action);
	if (action.MySpace == Space.World)
	_quaternionY = Quaternion.AngleAxis(newTransforms.y, Vector3.forward);
	else
	_quaternionY = Quaternion.AngleAxis(newTransforms.y, transform.forward);
	//transform.localRotation = originalRotation * _quaternionY;
	}
	else
	{
	newTransforms.w += pitch * (action.Sensitivity / 20);
	newTransforms.w = ClampFloat(newTransforms.w, action);
	}
	break;
	case Commons.InputType.Roll:
	float roll = InputManager.Instance.GetRoll(player);
	if (isRotation)
	{
	newTransforms.z += roll * (action.Sensitivity * 15);
	newTransforms.z = ClampAngle(newTransforms.z, action);
	if (action.MySpace == Space.World)
	_quaternionZ = Quaternion.AngleAxis(newTransforms.z, -Vector3.right);
	else
	_quaternionZ = Quaternion.AngleAxis(newTransforms.z, -transform.right);
	//transform.localRotation = originalRotation * _quaternionZ;
	}
	else
	{
	newTransforms.w += roll * (action.Sensitivity / 20);
	newTransforms.w = ClampFloat(newTransforms.w, action);
	}
	break;
	}
	//_amount = new Vector4(_amount.x += rotation1, _amount.y += rotation2, _amount.z += rotation3, _amount.w += distanceValue);
	if (isRotation)
	transform.localRotation = originalRotation * _quaternionX * _quaternionY * _quaternionZ;
	else
	switch (action.MoveVariables.MyMoveAxis)
	{
	case Commons.MoveAxis.X:
	transform.localPosition = new Vector3(newTransforms.w, 0, 0);
	break;
	case Commons.MoveAxis.Y:
	transform.localPosition = new Vector3(0, newTransforms.w, 0);
	break;
	case Commons.MoveAxis.Z:
	transform.localPosition = new Vector3(0, 0, newTransforms.w);
	break;
	default:
	break;
	}
	}
	private void ToggleHand(Commons.Hand hand, bool both = false)
	{
	Right = false;
	Left = false;
	if (both)
	{
	Right = true;
	Left = true;
	}
	else
	{
	if (hand == Commons.Hand.Right)
	Right = true;
	else
	Left = true;
	}
	}
	//code from unity mouselook script
	public float ClampAngle(float angle, LimbAction action)
	{
	angle = angle % 360;
	if ((angle >= -360F) && (angle <= 360F))
	{
	if (angle < -360F)
	{
	angle += 360F;
	}
	if (angle > 360F)
	{
	angle -= 360F;
	}
	}
	angle = Mathf.Clamp(angle, action.RotationVariables.MinAndMaxAngles.x, action.RotationVariables.MinAndMaxAngles.y);
	return angle;
	}
	public float ClampFloat(float value, LimbAction action)
	{
	return Mathf.Clamp(value, action.MoveVariables.MinAndMaxDistances.x, action.MoveVariables.MinAndMaxDistances.y);
	}
	}
	}

view raw LimbHandler.cs hosted with ❤ by GitHub

and inspector

	using Candlelight;
	using System.Collections;
	using System.Collections.Generic;
	using UnityEditor;
	using UnityEngine;
	using Fleshwound.Core;
	namespace Fleshwound.Editor
	{
	[CustomEditor(typeof(Core.LimbHandler))]
	public class LimbHandlerInspector : UnityEditor.Editor
	{
	Matrix4x4 startmatrix;
	private Core.LimbHandler script;
	private List<float> angleLimits = new List<float>();
	void OnEnable()
	{
	script = (Core.LimbHandler)target;
	startmatrix = script.transform.localToWorldMatrix;
	}
	void OnSceneGUI()
	{
	angleLimits.Clear();
	Vector3 position = script.transform.position;
	Vector3 scale = script.transform.lossyScale;
	Vector3 eulers = script.transform.eulerAngles;
	Quaternion q = Quaternion.Euler(eulers);
	if (SceneGUI.BeginHandles(script, "Modi..test test"))
	{
	Matrix4x4 m = Matrix4x4.identity;
	m.SetTRS(position, q, scale);
	Handles.matrix = m;
	//maxRot = ArcHandles.SolidAngle(0, maxRot, Vector3.zero, Quaternion.identity, 1);
	LimbAction[] actions = script.Actions;
	int i = 0;
	foreach (var item in actions)
	{
	angleLimits.Add(item.AngleLimit);
	Handles.color = item.HandleColor;
	switch (item.MyInputType)
	{
	case Commons.InputType.Yaw:
	if (item.MyTransformtype == Commons.TransformType.Rotate)
	{
	angleLimits[i] = ArcHandles.SolidWedge(0, angleLimits[i], Vector3.zero, Quaternion.Euler(0, 90, 0), 0.25f);
	}
	break;
	case Commons.InputType.Pitch:
	if (item.MyTransformtype == Commons.TransformType.Rotate)
	{
	angleLimits[i] = ArcHandles.SolidWedge(0, angleLimits[i], Vector3.zero, Quaternion.Euler(0, 90, 90), 0.25f);
	}
	break;
	case Commons.InputType.Roll:
	if (item.MyTransformtype == Commons.TransformType.Rotate)
	{
	angleLimits[i] = ArcHandles.SolidWedge(0, angleLimits[i], Vector3.zero, Quaternion.Euler(-90, -90, 0), 0.25f);
	}
	break;
	default:
	break;
	}
	i++;
	}
	}
	if (SceneGUI.EndHandles())
	{
	int x = 0;
	foreach (var item in script.Actions)
	{
	item.AngleLimit = angleLimits[x];
	item.RotationVariables.MinAndMaxAngles.x = (-angleLimits[x] / 2);
	item.RotationVariables.MinAndMaxAngles.y = (angleLimits[x] / 2);
	x++;
	}
	}
	}
	}
	}

view raw LimbHandlerInspector.cs hosted with ❤ by GitHub

Here is LimbAction, which is main class for any action LimbHandler handles

	using System;
	using UnityEngine;
	namespace Fleshwound.Core
	{
	[Serializable]
	public class LimbAction
	{
	public string name;
	public Color HandleColor;
	public bool Enabled = true;
	public Space MySpace;
	public Commons.Hand MyHand;
	public Commons.InputType MyInputType;
	public Commons.TransformType MyTransformtype;
	public Commons.ActionButtons[] MyActionButton;
	[Range(0f, 1f)]
	public float Sensitivity = 0.25f;
	public RotationVariables RotationVariables;
	public MoveVariables MoveVariables;
	[HideInInspector]
	public float AngleLimit;
	}
	[Serializable]
	public class RotationVariables
	{
	public Vector2 MinAndMaxAngles = new Vector2(-90, 90);
	}
	[Serializable]
	public class MoveVariables
	{
	public Transform DistanceOrigin;
	public Commons.MoveAxis MyMoveAxis;
	public Vector2 MinAndMaxDistances = new Vector2(0, 5);
	}
	}

view raw LimbAction.cs hosted with ❤ by GitHub

Here is the Common class

	using RootMotion.Dynamics;
	using System;
	using System.Collections;
	using System.Collections.Generic;
	using UnityEngine;
	namespace Fleshwound.Core
	{
	public static class Commons
	{
	public enum Hand { Right, Left, None }
	public enum InputType { Yaw, Pitch, Roll }
	public enum TransformType { Rotate, Scale, Move }
	public enum ActionButtons { None = 0, ActionButton1 = 1, ActionButton2 = 2, ActionButton3 = 3 }
	public enum MoveAxis { X = 1, Y = 2, Z = 3 }
	public static Rigidbody GetMuscleRigidbody(HumanBodyBones bone, PuppetMaster puppet, Animator animator)
	{
	Rigidbody rb = null;
	foreach (var item in puppet.muscles)
	{
	if (item.target == animator.GetBoneTransform(bone))
	rb = item.joint.GetComponent<Rigidbody>();
	}
	return rb;
	}
	public static Transform GetMuscleTarget(HumanBodyBones bone, PuppetMaster puppet, Animator animator)
	{
	Transform target = null;
	foreach (var item in puppet.muscles)
	{
	if (item.target == animator.GetBoneTransform(bone))
	target = item.target;
	}
	return target;
	}
	public static HumanBodyBones GetHumanbodyBonesByTransform(Transform trans, Animator animator)
	{
	HumanBodyBones hb = HumanBodyBones.Head;
	foreach (HumanBodyBones item in Enum.GetValues(typeof(HumanBodyBones)))
	{
	if (animator.GetBoneTransform(item) == trans)
	hb = item;
	}
	return hb;
	}
	public static ConfigurableJoint GetMuscleJoint(HumanBodyBones bone, PuppetMaster puppet, Animator animator)
	{
	ConfigurableJoint joint = null;
	foreach (var item in puppet.muscles)
	{
	if (item.target == animator.GetBoneTransform(bone))
	joint = item.joint;
	}
	return joint;
	}
	}
	static public class MethodExtensionForMonoBehaviourTransform
	{
	/// <summary>
	/// Gets or add a component. Usage example:
	/// BoxCollider boxCollider = transform.GetOrAddComponent<BoxCollider>();
	/// </summary>
	static public T GetOrAddComponent<T>(this Component child) where T : Component
	{
	T result = child.GetComponent<T>();
	if (result == null)
	{
	result = child.gameObject.AddComponent<T>();
	}
	return result;
	}
	}
	}

view raw Commons.cs hosted with ❤ by GitHub

And here is InputManager, it's really simple.

	using Rewired;
	using System.Collections;
	using System.Collections.Generic;
	using UnityEngine;
	namespace Fleshwound.Core
	{
	public class InputManager : Singleton<InputManager>
	{
	protected InputManager() { } // guarantee this will be always a singleton only - can't use the constructor!
	private float Yaw;
	private float Pitch;
	private float Roll;
	public bool b;
	private Player player;
	public bool GetRightHand(Player player)
	{
	return player.GetButtonDown("RightHand");
	}
	public bool GetLeftHand(Player player)
	{
	return player.GetButtonDown("LeftHand");
	}
	public bool GetBothHand(Player player)
	{
	return player.GetButtonDown("BothHands");
	}
	public float GetPitch(Player player)
	{
	return player.GetAxis("Pitch");
	}
	public bool GetAction1(Player player)
	{
	return player.GetButton("Action1");
	}
	public bool GetAction2(Player player)
	{
	return player.GetButton("Action2");
	}
	public bool GetAction3(Player player)
	{
	return player.GetButton("Action3");
	}
	public float GetYaw(Player player)
	{
	return player.GetAxis("Yaw");
	}
	public float GetRoll(Player player)
	{
	return player.GetAxis("Roll");
	}
	}
	}

view raw InputManager.cs hosted with ❤ by GitHub

Let there be limbs!

I finally managed to finish my dismember system. It's not perfect yet but working well enough for my current needs.

So overview of my system:

Bear in mind, that I'm not programmer so some of my code might look really stupid and unefficient.

I've separated every limb in blender to make my work easier in Unity.

I've also parented every mesh same way rig is parented. 

This way Unity will automatically make mesh hierarchy same as rig hierarchy. This is not mandatory but just makes things easier in Unity.

I'm using Puppetmaster to control character physics and FinalIK for Full Body IK movement which I use to control both hands.

Every breakable skinnedMesh has reference to of all of it's child skinnedMeshes which is called MyLimbs.

Every limb in Puppetmaster ragdoll has a reference to same skinnedMesh limb.

When ragdoll limbs gets too damaged it will break and call method BakeLimbs() from it's skinnedMesh counter part.

SkinnedMesh will then make new temporary GameObject, change position of this empty gameObject same as it is in Ragdoll limb and bake current vertex positions of skinnedMesh to a new gameobject and copy skinnedMesh materials.

Bakedmesh will copy rigidbody from puppetmaster and use reflection to copy whole ConfigurableJoint component from puppetmaster ragdoll to bakedMesh with one change,
ConfigurableJoint.connectedBody changed to correct parent.

Items are parented to Puppetmaster ragdoll so I need to check what is current item and change it's FixedJoint.connectedBody to bakedmesh hand gameobject.

Then I apply same velocities as it's on Puppetmaster Ragdoll so the dismembered limb will break naturally instead of just dropping off.

I had quite alot problems with adding collider with correct orientation so I add collider as a child of this new bakedMesh. This new collider copies properties from Puppetmaster ragdoll, and changes layer to correct one. (I did not know about reflection when I was doing collider part but ofc I could use it also here just like with ConfigurableJoint)

And finally disable old skinned mesh renderer.

It was much more work than I first thought but that is how game development always goes :-)

Here is my current codes, quite un-commented but I hope these are clear enough. Leave a comment if you have any questions!

First the code which is on every detachable skinnedmesh
Second code is on every breakable Puppetmaster ragdoll limb which can break.
Third is both Bone and Item components. 

	using UnityEngine;
	using System.Collections;
	using System.Collections.Generic;
	public class SkinnedMeshBaker : MonoBehaviour {
	public Bone MyBone;
	public List<SkinnedMeshRenderer> MyLimbs = new List<SkinnedMeshRenderer>();
	public GameObject[] StaticMeshes;
	private CapsuleCollider MyCollider;
	public Material injured;
	// Use this for initialization
	void Start ()
	{
	//MyLimbs.Add(this.GetComponent<SkinnedMeshRenderer>());
	foreach (SkinnedMeshRenderer smk in transform.GetComponentsInChildren<SkinnedMeshRenderer>())
	{
	MyLimbs.Add(smk);
	}
	StaticMeshes = new GameObject[MyLimbs.Count];
	}
	public void BakeLimbs(CapsuleCollider[] limbColliders, Item item)
	{
	injured = Resources.Load("Materials/Injured",typeof(Material)) as Material;
	for (int i = 0; i < MyLimbs.Count; i++)
	{
	Mesh bakedMesh = new Mesh();
	MyLimbs[i].transform.position = limbColliders[i].transform.position;
	MyLimbs[i].BakeMesh(bakedMesh);
	StaticMeshes[i] = new GameObject("dis_"+MyLimbs[i].name);
	// Setup its transforms
	StaticMeshes[i].transform.position = MyLimbs[i].transform.position;
	StaticMeshes[i].transform.rotation = MyLimbs[i].transform.rotation;
	StaticMeshes[i].transform.localScale = Vector3.one;
	// Parents
	if (i == 0)
	StaticMeshes[i].transform.parent = null;
	else
	StaticMeshes[i].transform.parent = StaticMeshes[i - 1].transform;
	// Colliders
	GameObject collider = new GameObject("col_"+MyLimbs[i].name);
	collider.gameObject.layer = 9;
	CapsuleCollider myCollider = collider.AddComponent<CapsuleCollider>();
	collider.transform.position = limbColliders[i].transform.position;
	collider.transform.rotation = limbColliders[i].transform.rotation;
	myCollider.center = limbColliders[i].center;
	myCollider.radius = limbColliders[i].radius;
	myCollider.height = limbColliders[i].height;
	myCollider.direction = limbColliders[i].direction;
	collider.transform.parent = StaticMeshes[i].transform;
	// Setup the rendering components
	StaticMeshes[i].AddComponent<MeshFilter>().sharedMesh = bakedMesh;
	Material[] tempMaterials = MyLimbs[i].sharedMaterials;
	tempMaterials[1] = injured;
	StaticMeshes[i].AddComponent<MeshRenderer>().sharedMaterials = tempMaterials;
	StaticMeshes[i].GetComponent<MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
	// Setup rigidbodies
	StaticMeshes[i].AddComponent<Rigidbody>().mass = limbColliders[i].GetComponent<Rigidbody>().mass;
	// joints...
	if (i == 0)
	{
	//nothing
	}
	else
	{
	ConfigurableJoint tempjoint = limbColliders[i].GetComponent<ConfigurableJoint>();
	StaticMeshes[i].AddComponent<ConfigurableJoint>().GetCopyOf(tempjoint);
	StaticMeshes[i].GetComponent<ConfigurableJoint>().connectedBody = StaticMeshes[i - 1].GetComponent<Rigidbody>();
	StaticMeshes[i].GetComponent<ConfigurableJoint>().anchor = new Vector3(0, 0, 0);
	}
	// Setup item
	if (i == (MyLimbs.Count - 1))
	{
	item.transform.SetParent(StaticMeshes[i].transform);
	item.ChangeMyConnectedRigidbody(StaticMeshes[i].GetComponent<Rigidbody>());
	}
	//apply velocity
	StaticMeshes[i].GetComponent<Rigidbody>().velocity = limbColliders[i].GetComponent<Rigidbody>().velocity*2;
	StaticMeshes[i].GetComponent<Rigidbody>().angularVelocity = limbColliders[i].GetComponent<Rigidbody>().angularVelocity*2;
	MyLimbs[i].gameObject.SetActive(false);
	}
	}
	}

view raw SkinnedMeshBake hosted with ❤ by GitHub

	using UnityEngine;
	using UnityEngine.UI;
	using System.Collections;
	using System.Collections.Generic;
	using RootMotion;
	using RootMotion.Dynamics;
	public class JointBreak : MonoBehaviour
	{
	public PuppetMaster puppet;
	public SkinnedMeshRenderer mySkinnedMesh;
	private Item myItem;
	private CapsuleCollider[] _colliders;
	[SerializeField]
	private Text myText;
	[SerializeField]
	private Text myText2;
	public bool breakMe = false;
	public bool breakMe2 = false;
	// Use this for initialization
	void Start()
	{
	if (puppet == null)
	{
	Debug.Log(transform.name + ": Puppet empty");
	puppet = GetComponentInParent<PuppetMaster>();
	}
	_colliders = GetComponentsInChildren<CapsuleCollider>();
	CheckForItem();
	}
	public void CheckForItem()
	{
	foreach (Item child in GetComponentsInChildren<Item>())
	myItem = child;
	}
	// Update is called once per frame
	void Update()
	{
	if (myText)
	{
	myText.text = this.GetComponent<Rigidbody>().velocity.ToString();
	myText2.text = this.GetComponent<Rigidbody>().angularVelocity.ToString();
	}
	if (breakMe)
	{
	if (Input.GetKeyDown(KeyCode.U))
	{
	mySkinnedMesh.GetComponent<SkinnedMeshBaker>().BakeLimbs(_colliders, myItem);
	puppet.RemoveMuscleRecursive (this.GetComponent<ConfigurableJoint> (), false);
	}
	}
	if (breakMe2)
	{
	if (Input.GetKeyDown(KeyCode.I))
	{
	mySkinnedMesh.GetComponent<SkinnedMeshBaker>().BakeLimbs(_colliders, myItem);
	puppet.RemoveMuscleRecursive (this.GetComponent<ConfigurableJoint> (), false);
	}
	}
	}
	void OnJointBreak(float breakForce)
	{
	Debug.Log("A joint '"+transform.name+ "' has just been broken!, force: " + breakForce);
	DismemberMe();
	//transform.parent = null;
	}
	public void DismemberMe()
	{
	mySkinnedMesh.GetComponent<SkinnedMeshBaker>().BakeLimbs(_colliders, myItem);
	puppet.RemoveMuscleRecursive (this.GetComponent<ConfigurableJoint> (), false);
	}
	}

view raw JointBreak hosted with ❤ by GitHub

	using UnityEngine;
	using System.Collections;
	[ExecuteInEditMode]
	public class Bone : MonoBehaviour {
	public Bone[] myBones;
	// Use this for initialization
	void Awake()
	{
	myBones = GetComponentsInChildren<Bone>();
	}
	--------
	item
	--------
	using UnityEngine;
	using System.Collections;
	public class Item : MonoBehaviour {
	// Use this for initialization
	private FixedJoint fj;
	void Start ()
	{
	fj = GetComponent<FixedJoint>();
	}
	public void ChangeMyConnectedRigidbody(Rigidbody rb)
	{
	fj.connectedBody = rb;
	}

view raw Bone and Item hosted with ❤ by GitHub

Blog for my own game development rants.

Here I will update the progress of my personal game project which is heavily inspired by the old game Die by the Sword

This project is still at really early stage.

Currently I have arm movement working with rotation limits.
Player can rotate shoulder on two axes,wrist on three axes and extend/curtail arm.

Current controls are:
Press 1 to make right hand active
Press 2 to make left hand active

While left mouse button is held down:
Mouse Y adjusts shoulder pitch
Mouse X adjusts shoulder yaw

While right mouse button is held down:
Mouse Y adjusts wrist roll
Mouse X adjusts wrist yaw
Mouse Wheel adjusts wrist pitch

While middle mouse button is held down:
Mouse Y adjusts extending/curtailing of arm

Player can simultaneously adjust shoulder and wrist

Here is a video of arm movement.

Next job is to finish elbow target which gets a bit weird when wrist is rotated that hand palm is facing up. Problem can be seen in the video below.

After that to an interesting topic, dismembering of limbs.

Here is link to my current to-do list which I will update when ever I manage to think something nice I would want to have in my project.