C# Vessel.BackupVessel方法代码示例

        private void OnVesselCreate(Vessel vessel)
        {
            ProtoVessel pv = vessel.BackupVessel();
            List<uint> vesselParts = new List<uint>();
            bool killShip = false;
            bool vesselOk = false;
            foreach (ProtoPartSnapshot pps in pv.protoPartSnapshots)
            {
                if (pps.flightID == 0)
                {
                    loadGuid = vessel.id;
                    //When you spawn a new vessel in all the part ID's are 0 until OnFlightReady.
                    return;
                }
                vesselParts.Add(pps.flightID);
                if (partToVessel.ContainsKey(pps.flightID))
                {
                    killShip = true;
                    foreach (Vessel otherVessel in partToVessel[pps.flightID])
                    {
                        if (otherVessel.id == vessel.id)
                        {
                            vesselOk = true;
                        }
                        //Either of the locks are ours or neither of the locks exist
                        if (LockSystem.fetch.LockIsOurs("control-" + otherVessel.id) || LockSystem.fetch.LockIsOurs("update-" + otherVessel.id) || (!LockSystem.fetch.LockExists("control-" + otherVessel.id) && !LockSystem.fetch.LockExists("update-" + otherVessel.id)))
                        {
                            vesselOk = true;
                        }
                    }
                }
            }
            if (killShip && !vesselOk)
            {
                DarkLog.Debug("PartKiller: Destroying vessel fragment");
                vessel.Die();
            }
            else
            {
                vesselToPart.Add(vessel, vesselParts);
                foreach (uint partID in vesselParts)
                {
                    if (!partToVessel.ContainsKey(partID))
                    {
                        partToVessel.Add(partID, new List<Vessel>());
                    }
                    partToVessel[partID].Add(vessel);
                }
            }

        }

 private void OnVesselWillDestroy(Vessel vessel)
 {
     bool pilotedByAnotherPlayer = LockSystem.fetch.LockExists("control-" + vessel.id) && !LockSystem.fetch.LockIsOurs("control-" + vessel.id);
     bool updatedByAnotherPlayer = LockSystem.fetch.LockExists("update-" + vessel.id) && !LockSystem.fetch.LockIsOurs("update-" + vessel.id);
     bool updatedInTheFuture = VesselWorker.fetch.VesselUpdatedInFuture(vessel.id);
     //Vessel was packed within the last 5 seconds
     if (lastPackTime.ContainsKey(vessel.id) && (UnityEngine.Time.realtimeSinceStartup - lastPackTime[vessel.id]) < 5f)
     {
         lastPackTime.Remove(vessel.id);
         if (vessel.situation == Vessel.Situations.FLYING && (pilotedByAnotherPlayer || updatedByAnotherPlayer || updatedInTheFuture))
         {
             DarkLog.Debug("Hacky load: Saving player vessel getting packed in atmosphere");
             ProtoVessel pv = vessel.BackupVessel();
             ConfigNode savedNode = new ConfigNode();
             pv.Save(savedNode);
             VesselWorker.fetch.LoadVessel(savedNode, vessel.id, true);
         }
     }
     if (lastPackTime.ContainsKey(vessel.id))
     {
         lastPackTime.Remove(vessel.id);
     }
 }

        public static void UnhangarCraft(Vessel vVesselStored, StaticObject soHangar)
        {
            RemoveCorrectCraft(vVesselStored, soHangar);

            // Convert the stored protovessel to a new protovessel.
            // Use BackupVessel because that seems to work and protovessel does not. `\o/`
            ProtoVessel pVessel = vVesselStored.BackupVessel();

            // Get rid of the original hidden vessel - even though it was unloaded KSP still 'sees' the original craft.
            // I do not care why. :|
            vVesselStored.state = Vessel.State.DEAD;

            foreach (Part p in vVesselStored.Parts)
            {
                if (p != null && p.gameObject != null)
                    p.gameObject.DestroyGameObject();
            }

            // Load the new protovessel we made. KSP won't reload (or rather render) a vessel that was unloaded - it will only load a protovessel. :$
            pVessel.Load(FlightDriver.FlightStateCache.flightState);
            // I suspect this is actually a KSP bug since the same crap happens with newly spawned static objects. If you query the active state
            // of the invisible craft, it claims it is active. And no, forcing the renderers doesn't work either.

            // Convert protovessel to vessel
            Vessel vNewVessel = pVessel.vesselRef;

            // Unload then reload the vessel - this seems to be the way to properly re-initialise flightstate etc.
            // Don't do this and you get a craft with a stuck surface velocity reading. It looks like KSP transposes orbital
            // and surface velocity or some other stupid s**t. I don't care.
            // And yes, this time KSP does load an unloaded vessel with no need for protovessel b******t. I don't care why.
            vNewVessel.Unload();
            vNewVessel.Load();
        }

 public void OnVesselCreate(Vessel createdVessel)
 {
     try
     {
         //DarkLog.Debug("Vessel creation detected: " + createdVessel.id + ", name: " + createdVessel.vesselName);
         ProtoVessel pv = createdVessel.BackupVessel();
         bool killShip = false;
         bool spawnDebris = false;
         string partOwner = null;
         string createdVesselID = pv.vesselID.ToString();
         foreach (ProtoPartSnapshot vesselPart in pv.protoPartSnapshots)
         {
             if (vesselPart != null)
             {
                 if (vesselParts.ContainsKey(vesselPart.flightID.ToString()))
                 {
                     partOwner = vesselParts[vesselPart.flightID.ToString()];
                     if (!killShip && (createdVesselID != partOwner))
                     {
                         if (LockSystem.fetch.LockIsOurs("control-" + partOwner) || LockSystem.fetch.LockIsOurs("update-" + partOwner) || !LockSystem.fetch.LockExists("update-" + partOwner))
                         {
                             //Vessel is ours, update the part owner.
                             spawnDebris = true;
                             vesselParts[vesselPart.flightID.ToString()] = createdVesselID;
                         }
                         else
                         {
                             DarkLog.Debug("Detected debris for a vessel we do not control, removing " + createdVesselID);
                             killShip = true;
                             break;
                         }
                     }
                 }
             }
         }
         if (killShip)
         {
             createdVessel.Die();
         }
         if (spawnDebris)
         {
             //DarkLog.Debug("Spawned debris " + createdVesselID + " from " + partOwner);
         }
     }
     catch (Exception e)
     {
         DarkLog.Debug("Threw in OnVesselCreate: " + e);
     }
 }

 private void CheckVesselParts(Vessel checkVessel)
 {
     List<string> allowedParts = ModWorker.fetch.GetAllowedPartsList();
     List<string> bannedParts = new List<string>();
     ProtoVessel checkProto = checkVessel.BackupVessel();
     foreach (ProtoPartSnapshot part in checkProto.protoPartSnapshots)
     {
         if (!allowedParts.Contains(part.partName))
         {
             if (!bannedParts.Contains(part.partName))
             {
                 bannedParts.Add(part.partName);
             }
         }
     }
     if (checkVessel.isActiveVessel)
     {
         bannedPartsString = "";
         foreach (string bannedPart in bannedParts)
         {
             bannedPartsString += bannedPart + "\n";
         }
     }
     DarkLog.Debug("Checked vessel " + checkVessel.id.ToString() + " for banned parts, is ok: " + (bannedParts.Count == 0));
     vesselPartsOk[checkVessel.id] = (bannedParts.Count == 0);
 }

        private bool loadVesselForRendezvous(ProtoVessel placeVessel, Vessel targetVessel)
        {
            targetVessel.BackupVessel();

            placeVessel.orbitSnapShot = targetVessel.protoVessel.orbitSnapShot;

            placeVessel.orbitSnapShot.epoch = 0.0;

            tempID = rand.Next(1000000000).ToString();
            //rename any vessels present with "AdministativeDockingName"
            foreach (Vessel ve in FlightGlobals.Vessels)
            {
                if (ve.vesselName == tempID)
                {
                    Vessel NameVessel = null;
                    NameVessel = ve;
                    NameVessel.vesselName = "1";
                }
            }

            placeVessel.vesselID = Guid.NewGuid();

            placeVessel.vesselName = tempID;

            foreach (ProtoPartSnapshot p in placeVessel.protoPartSnapshots)
            {
                if (placeVessel.refTransform == p.flightID)
                {
                    p.flightID = (UInt32)rand.Next(1000000000, 2147483647);
                    placeVessel.refTransform = p.flightID;
                }
                else
                {
                    p.flightID = (UInt32)rand.Next(1000000000, 2147483647);
                }

                if (p.protoModuleCrew != null && p.protoModuleCrew.Count() != 0)
                {
                    List<ProtoCrewMember> cl = p.protoModuleCrew;
                    List<ProtoCrewMember> clc = new List<ProtoCrewMember>(cl);

                    foreach (ProtoCrewMember c in clc)
                    {
                        p.RemoveCrew(c);
                        //print("remove");
                    }
                }
            }

            try
            {
                placeVessel.Load(HighLogic.CurrentGame.flightState);
                return true;
            }
            catch
            {
                //abortArrival();
                //return false;
                return true;
            }
        }

 public StoredVessel(Vessel vsl, bool compute_hull=false)
 {
     proto_vessel = vsl.BackupVessel();
     metric = new Metric(vsl, compute_hull);
     id     = proto_vessel.vesselID;
     name   = proto_vessel.vesselName;
     crew   = vsl.GetVesselCrew();
     resources = new VesselResources<ProtoVessel, ProtoPartSnapshot, ProtoPartResourceSnapshot>(proto_vessel);
 }

 private void OnVesselWasModified(Vessel vessel)
 {
     if (!vesselToPart.ContainsKey(vessel))
     {
         //Killed as a fragment.
         return;
     }
     List<uint> addList = new List<uint>();
     List<uint> removeList = new List<uint>(vesselToPart[vessel]);
     ProtoVessel pv = vessel.BackupVessel();
     foreach (ProtoPartSnapshot pps in pv.protoPartSnapshots)
     {
         if (removeList.Contains(pps.flightID))
         {
             removeList.Remove(pps.flightID);
         }
         else
         {
             addList.Add(pps.flightID);
         }
     }
     foreach (uint partID in addList)
     {
         if (!partToVessel.ContainsKey(partID))
         {
             partToVessel.Add(partID, new List<Vessel>());
         }
         partToVessel[partID].Add(vessel);
         vesselToPart[vessel].Add(partID);
     }
     foreach (uint partID in removeList)
     {
         vesselToPart[vessel].Remove(partID);
         partToVessel[partID].Remove(vessel);
         if (partToVessel[partID].Count == 0)
         {
             partToVessel.Remove(partID);
         }
     }
 }

 public StoredVessel(Vessel vsl)
 {
     vessel = vsl.BackupVessel();
     metric = new Metric(vsl);
     id     = vessel.vesselID;
     CoM    = vsl.findLocalCenterOfMass();
     crew   = vsl.GetVesselCrew();
     resources = new VesselResources<ProtoVessel, ProtoPartSnapshot, ProtoPartResourceSnapshot>(vessel);
     //			fixTripLogger(); //FIXME
 }

        public void SendVesselUpdateIfNeeded(Vessel checkVessel)
        {
            //Check vessel parts
            if (ModWorker.fetch.modControl != ModControlMode.DISABLED)
            {
                if (!vesselPartsOk.ContainsKey(checkVessel.id))
                {
                    CheckVesselParts(checkVessel);
                }
                if (!vesselPartsOk[checkVessel.id])
                {
                    //Vessel with bad parts
                    return;
                }
            }

            if (checkVessel.state == Vessel.State.DEAD)
            {
                //Don't send dead vessels
                return;
            }

            if (checkVessel.vesselType == VesselType.Flag && checkVessel.id == Guid.Empty && checkVessel.vesselName != "Flag")
            {
                DarkLog.Debug("Fixing flag GUID for " + checkVessel.vesselName);
                checkVessel.id = Guid.NewGuid();
            }

            //Only send updates for craft we have update locks for. Request the lock if it's not taken.
            if (!LockSystem.fetch.LockExists("update-" + checkVessel.id.ToString()))
            {
                LockSystem.fetch.ThrottledAcquireLock("update-" + checkVessel.id.ToString());
            }

            // Check if it isn't null before fetching it
            if (FlightGlobals.fetch.activeVessel != null)
            {
                //Take the update lock off another player if we have the control lock and it's our vessel
                if (checkVessel.id == FlightGlobals.fetch.activeVessel.id)
                {
                    if (LockSystem.fetch.LockExists("update-" + checkVessel.id.ToString()) && !LockSystem.fetch.LockIsOurs("update-" + checkVessel.id.ToString()) && LockSystem.fetch.LockIsOurs("control-" + checkVessel.id.ToString()))
                    {
                        LockSystem.fetch.ThrottledAcquireLock("update-" + checkVessel.id.ToString());
                        //Wait until we have the update lock
                        return;
                    }
                }
            }

            //Send updates for unpacked vessels that aren't being flown by other players
            bool notRecentlySentProtoUpdate = serverVesselsProtoUpdate.ContainsKey(checkVessel.id) ? ((UnityEngine.Time.realtimeSinceStartup - serverVesselsProtoUpdate[checkVessel.id]) > VESSEL_PROTOVESSEL_UPDATE_INTERVAL) : true;
            bool notRecentlySentPositionUpdate = serverVesselsPositionUpdate.ContainsKey(checkVessel.id) ? ((UnityEngine.Time.realtimeSinceStartup - serverVesselsPositionUpdate[checkVessel.id]) > (1f / (float)DynamicTickWorker.fetch.sendTickRate)) : true;

            //Check that is hasn't been recently sent
            if (notRecentlySentProtoUpdate)
            {
                ProtoVessel checkProto = checkVessel.BackupVessel();
                //TODO: Fix sending of flying vessels.
                if (checkProto != null)
                {
                    if (checkProto.vesselID != Guid.Empty)
                    {
                        //Also check for kerbal state changes
                        foreach (ProtoPartSnapshot part in checkProto.protoPartSnapshots)
                        {
                            foreach (ProtoCrewMember pcm in part.protoModuleCrew.ToArray())
                            {
                                SendKerbalIfDifferent(pcm);
                            }
                        }
                        RegisterServerVessel(checkProto.vesselID);
                        //Mark the update as sent
                        serverVesselsProtoUpdate[checkVessel.id] = UnityEngine.Time.realtimeSinceStartup;
                        //Also delay the position send
                        serverVesselsPositionUpdate[checkVessel.id] = UnityEngine.Time.realtimeSinceStartup;
                        latestUpdateSent[checkVessel.id] = UnityEngine.Time.realtimeSinceStartup;
                        bool isFlyingUpdate = (checkProto.situation == Vessel.Situations.FLYING);
                        NetworkWorker.fetch.SendVesselProtoMessage(checkProto, false, isFlyingUpdate);
                    }
                    else
                    {
                        DarkLog.Debug(checkVessel.vesselName + " does not have a guid!");
                    }
                }
            }
            else if (notRecentlySentPositionUpdate && checkVessel.vesselType != VesselType.Flag)
            {
                //Send a position update - Except for flags. They aren't exactly known for their mobility.
                serverVesselsPositionUpdate[checkVessel.id] = UnityEngine.Time.realtimeSinceStartup;
                latestUpdateSent[checkVessel.id] = UnityEngine.Time.realtimeSinceStartup;
                VesselUpdate update = VesselUpdate.CopyFromVessel(checkVessel);
                if (update != null)
                {
                    NetworkWorker.fetch.SendVesselUpdate(update);
                }
            }
        }