BarMagnet Mod

using System;
using System.Collections.Generic;
using spaar.ModLoader;
using TheGuysYouDespise;
using UnityEngine;

namespace Blocks {
    public class BarMagnetLoader : BlockMod {
        public override string Name { get { return "BarMagnet"; } }
        public override string DisplayName { get { return "BarMagnet"; } }
        public override string Author { get { return "ITR"; } }
        public override Version Version { get { return new Version(1,0); } }

        protected Block block = new Block()
            .ID(0xC7)
            .BlockName("Bar Magnet")
            .Obj(new List<Obj> { new Obj("BarMagnet.obj","BarMagnet.png",
            new VisualOffset(Vector3.one,Vector3.zero,Vector3.zero))})
            .IconOffset(new Icon(new Vector3(1,1f,0), new Vector3(0,-0.25f,0), Vector3.zero))
            .Components(new Type[] { typeof(BarMagnet),})
            .Properties(new BlockProperties().SearchKeywords(new string[] {
                "Magnet","Electric","Modded","Magic","Force"}))
            .Mass(0.5f)
            .ShowCollider(false)
            .CompoundCollider(new List<ColliderComposite> { new ColliderComposite(
                new Vector3(0.9f, 0.9f, 1.8f), new Vector3(0f, 0f, 1.05f), new Vector3(0f, 0f, 0f)) })
            .IgnoreIntersectionForBase()
            .NeededResources(new List<NeededResource>())
            .AddingPoints(new List<AddingPoint> {
                new BasePoint(true, true).Motionable(false,false,false).SetStickyRadius(0.5f),
                new AddingPoint(new Vector3(0f, 0f, 1.5f), new Vector3(-90f, 0f, 0f),true).SetStickyRadius(0.3f),
            });

        public override void OnLoad() {
            Game.OnSimulationToggle += ResetList;
            spaar.Commands.RegisterHelpMessage("BarMagnet commands:\n   MaxDistance [int]\n MagnetForce [float]");
            spaar.Commands.RegisterCommand("MaxDistance",(args,namedArgs) => {
                try {
                    BarMagnet.maxDistance = float.Parse(args[0]);
                }
                catch {
                    return "MaxDistance is "+BarMagnet.maxDistance.ToString();
                }
                return "MaxDistance was set to "+BarMagnet.maxDistance.ToString();
            },"Changes the MaxDistance of the magnets (lower numbers make it less laggy)");

            spaar.Commands.RegisterCommand("MagnetForce",(args,namedArgs) => {
                try {
                    BarMagnet.force = float.Parse(args[0]);
                }
                catch {
                    return "MagnetForce is "+BarMagnet.force.ToString();
                }
                return "MagnetForce was set to "+BarMagnet.force.ToString();
            },"Changes the default force of the magnets (force slider set to 1)");
            LoadBlock(block);
        }

        public override void OnUnload() { }

        public static List<BarMagnet> barMagnetList = new List<BarMagnet>();

        public static void ResetList(bool isSimulating) {
            if(!isSimulating)
                barMagnetList = new List<BarMagnet>();
        }

        public static int AddToList(BarMagnet barMagnet) {
            int ret = barMagnetList.Count;
            barMagnetList.Add(barMagnet);
            return ret;
        }

    }

    public class BarMagnet : GenericBlock {
        int myID = -1;
        MToggle inverted;
        MSlider forceMult;
        public static float maxDistance = 100f;
        public static float force = 200;
        public Vector3 pos1;
        public Vector3 pos2;
        public Rigidbody rigidBody;
        public Joint[] joints;

        protected void Awake() {
            inverted=AddToggle("Invert", "inverted", false);
            forceMult=AddSlider("ForceMult", "forceMult", 1, -5, 5);
            if(StatMaster.isSimulating) {
                myID=BarMagnetLoader.AddToList(this);
                rigidBody=GetComponent<Rigidbody>();
                rigidBody.centerOfMass=Vector3.forward;
                joints=new Joint[myID];
            }
        }

        public void FixedUpdate() {
            if(StatMaster.isSimulating) {
                if(inverted.IsActive) {
                    pos1=transform.position+transform.forward*transform.localScale.z*1.5f;
                    pos2=transform.position+transform.forward*transform.localScale.z/2;
                } else {
                    pos2=transform.position+transform.forward*transform.localScale.z*1.5f;
                    pos1=transform.position+transform.forward*transform.localScale.z/2;
                }
                if(myID!=-1) {
                    for(int i = 0; i<myID; i++) {
                        CalculateForce(BarMagnetLoader.barMagnetList[i]);
                    }
                }
            }
        }

        public void CalculateForce(BarMagnet barMagnet) {
            if(joints[barMagnet.myID]!=null&&joints[barMagnet.myID].connectedBody!=null) {
                return;
            }
            if(Vector3.Distance(transform.position+transform.forward,barMagnet.transform.position+barMagnet.transform.forward)>maxDistance)
                return;
            if(pos1==barMagnet.pos2||pos2==barMagnet.pos1) {
                return;
            }
            if(Vector3.Distance(pos1,barMagnet.pos2)<0.3f) {
                barMagnet.rigidBody.AddForceAtPosition((pos1-barMagnet.pos2).normalized,barMagnet.pos2);
                rigidBody.AddForceAtPosition((barMagnet.pos2-pos1).normalized,pos1);
                return;
            }
            if(Vector3.Distance(pos2,barMagnet.pos1)<0.3f) {
                barMagnet.rigidBody.AddForce((pos2-barMagnet.pos1).normalized);
                rigidBody.AddForce((barMagnet.pos1-pos2).normalized);
                return;
            }
            var lForce = force*(forceMult.Value+barMagnet.forceMult.Value);

            Vector3 Pp, Pn, Np, Nn;
            float mag;
            Pn = barMagnet.pos2-pos1;
            Np = barMagnet.pos1-pos2;
            if((Pn-Np).sqrMagnitude<=0.0025) {
                mag=Pn.magnitude;
                var l = transform.InverseTransformVector(Np);
                if(l.x>=-0.95f&&l.x<=0.95f&&l.y>=-0.95f&&l.y<=0.95f&&l.z>=-0.95f&&l.z<=0.95f) {
                    var joint = joints[barMagnet.myID];
                    if(joint==null) {
                        joint = gameObject.AddComponent<FixedJoint>();
                        joint.connectedBody=barMagnet.rigidBody;
                        joint.breakForce=lForce*2;
                        joint.breakTorque=lForce*2;
                        joints[barMagnet.myID]=joint;
                    }else if(joint.connectedBody==null) {
                        joint.connectedBody=barMagnet.rigidBody;
                        joint.breakForce=lForce*2;
                        joint.breakTorque=lForce*2;
                    }
                    return;
                }

                if(mag>100) {
                    Pn*=100/mag;
                }
                Pn=Pn.normalized/(Vector3.SqrMagnitude(Pn));
                barMagnet.rigidBody.AddForceAtPosition(lForce*-2*Pn, (barMagnet.pos1+barMagnet.pos2)/2);
                rigidBody.AddForceAtPosition(lForce*2*Pn, (pos1+pos2)/2);
                return;
            }

            Pp = barMagnet.pos1-pos1;
            Nn = barMagnet.pos2-pos2;
            Pp = Pp.normalized/(Vector3.SqrMagnitude(Pp));
            Pn = Pn.normalized/(Vector3.SqrMagnitude(Pn));
            Np = Np.normalized/(Vector3.SqrMagnitude(Np));
            Nn = Nn.normalized/(Vector3.SqrMagnitude(Nn));

            mag = Pp.magnitude;
            if(mag>100) {
                Pp*=100/mag;
            }
            mag=Pn.magnitude;
            if(mag>100) {
                Pn*=100/mag;
            }
            mag=Np.magnitude;
            if(mag>100) {
                Np*=100/mag;
            }
            mag=Nn.magnitude;
            if(mag>100) {
                Nn*=100/mag;
            }

            barMagnet.rigidBody.AddForceAtPosition((Pp-Np)*lForce, barMagnet.pos1);
            barMagnet.rigidBody.AddForceAtPosition((Nn-Pn)*lForce, barMagnet.pos2);
            rigidBody.AddForceAtPosition((Pn-Pp)*lForce, pos1);
            rigidBody.AddForceAtPosition((Np-Nn)*lForce, pos2);
        }

        public override void OnLoad(XDataHolder stream) {
            base.OnLoad(stream);
            this.LoadMapperValues(stream);
        }

        public override void OnSave(XDataHolder stream) {
            base.OnSave(stream);
            this.SaveMapperValues(stream);
        }
    }
}