public void ShipyardSwap(JournalShipyardSwap e, string station, string system)
        {
            if (e.StoreShipId.HasValue)     // if we have an old ship ID (old records do not)
            {
                string oldship = Key(e.StoreOldShipFD, e.StoreShipId.Value);

                if (Ships.ContainsKey(oldship))
                {
                    //System.Diagnostics.Debug.WriteLine(oldship + " Swap Store at " + system + ":" + station);
                    Ships[oldship] = Ships[oldship].Store(station, system);
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine(e.StoreOldShipFD + " Cant find to swap");
                }
            }
            else
            {
                System.Diagnostics.Debug.WriteLine(e.StoreOldShipFD + " Cant find to swap");
            }

            string sid = Key(e.ShipFD, e.ShipId);           //swap to new ship

            //System.Diagnostics.Debug.WriteLine(sid + " Swap to at " + system);

            ShipInformation sm = EnsureShip(sid);                 // this either gets current ship or makes a new one.

            sm         = sm.SetShipDetails(e.ShipType, e.ShipFD); // shallow copy if changed
            sm         = sm.SwapTo();                             // swap into
            Ships[sid] = sm;
            currentid  = sid;
            VerifyList();
        }
Example #2
0
        public void ShipyardSwap(JournalShipyardSwap e)
        {
            ShipInformation sm = EnsureShip(e.ShipId);      // this either gets current ship or makes a new one.

            Ships[e.ShipId] = sm.Set(e.ShipType, e.ShipFD); // shallow copy if changed
            currentid       = e.ShipId;
        }
        public static HistoryEntryStatus Update(HistoryEntryStatus prev, JournalEntry je, string curStarSystem)
        {
            if (prev == null)
            {
                prev = new HistoryEntryStatus();
            }

            switch (je.EventTypeID)
            {
            case JournalTypeEnum.Location:
                JournalLocation jloc = je as JournalLocation;
                TravelStateType t    = jloc.Docked ? TravelStateType.Docked : (jloc.Latitude.HasValue ? TravelStateType.Landed : TravelStateType.NormalSpace);

                return(new HistoryEntryStatus(prev)         // Bodyapproach copy over we should be in the same state as last..
                {
                    TravelState = t,
                    MarketId = jloc.MarketID,
                    BodyID = jloc.BodyID,
                    BodyType = jloc.BodyType,
                    BodyName = jloc.Body,
                    Wanted = jloc.Wanted,
                    StationName = jloc.StationName.Alt(null),           // if empty string, set to null
                    StationType = jloc.StationType.Alt(null),
                });

            case JournalTypeEnum.FSDJump:
                JournalFSDJump jfsd = (je as JournalFSDJump);
                return(new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.Hyperspace,
                    MarketId = null,
                    BodyID = -1,
                    BodyType = "Star",
                    BodyName = jfsd.StarSystem,
                    Wanted = jfsd.Wanted,
                    StationName = null,
                    StationType = null,
                    BodyApproached = false,
                });

            case JournalTypeEnum.LoadGame:
                JournalLoadGame jlg        = je as JournalLoadGame;
                bool            isbuggy    = ShipModuleData.IsSRV(jlg.ShipFD);
                string          shiptype   = isbuggy ? prev.ShipType : jlg.Ship;
                string          shiptypefd = isbuggy ? prev.ShipTypeFD : jlg.ShipFD;
                int             shipid     = isbuggy ? prev.ShipID : jlg.ShipId;

                return(new HistoryEntryStatus(prev)  // Bodyapproach copy over we should be in the same state as last..
                {
                    OnCrewWithCaptain = null,        // can't be in a crew at this point
                    GameMode = jlg.GameMode,         // set game mode
                    Group = jlg.Group,               // and group, may be empty
                    TravelState = (jlg.StartLanded || isbuggy) ? TravelStateType.Landed : prev.TravelState,
                    ShipType = shiptype,
                    ShipID = shipid,
                    ShipTypeFD = shiptypefd,
                });

            case JournalTypeEnum.Docked:
                JournalDocked jdocked = (JournalDocked)je;
                return(new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.Docked,
                    MarketId = jdocked.MarketID,
                    Wanted = jdocked.Wanted,
                    StationName = jdocked.StationName,
                    StationType = jdocked.StationType,
                });

            case JournalTypeEnum.Undocked:
                return(new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.NormalSpace,
                    MarketId = null,
                    StationName = null,
                    StationType = null,
                });

            case JournalTypeEnum.Touchdown:
                if (((JournalTouchdown)je).PlayerControlled == true)            // can get this when not player controlled
                {
                    return(new HistoryEntryStatus(prev)
                    {
                        TravelState = TravelStateType.Landed,
                    });
                }
                else
                {
                    return(prev);
                }

            case JournalTypeEnum.Liftoff:
                if (((JournalLiftoff)je).PlayerControlled == true)             // can get this when not player controlled
                {
                    return(new HistoryEntryStatus(prev)
                    {
                        TravelState = TravelStateType.NormalSpace,
                    });
                }
                else
                {
                    return(prev);
                }

            case JournalTypeEnum.SupercruiseExit:
                JournalSupercruiseExit jsexit = (JournalSupercruiseExit)je;
                return(new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.NormalSpace,
                    BodyName = (prev.BodyApproached) ? prev.BodyName : jsexit.Body,
                    BodyType = (prev.BodyApproached) ? prev.BodyType : jsexit.BodyType,
                    BodyID = (prev.BodyApproached) ? prev.BodyID : jsexit.BodyID,
                });

            case JournalTypeEnum.SupercruiseEntry:
                return(new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.Hyperspace,
                    BodyName = !prev.BodyApproached ? curStarSystem : prev.BodyName,
                    BodyType = !prev.BodyApproached ? "Star" : prev.BodyType,
                    BodyID = !prev.BodyApproached ? -1 : prev.BodyID,
                });

            case JournalTypeEnum.ApproachBody:
                JournalApproachBody jappbody = (JournalApproachBody)je;
                return(new HistoryEntryStatus(prev)
                {
                    BodyApproached = true,
                    BodyType = jappbody.BodyType,
                    BodyName = jappbody.Body,
                    BodyID = jappbody.BodyID,
                });

            case JournalTypeEnum.LeaveBody:
                JournalLeaveBody jlbody = (JournalLeaveBody)je;
                return(new HistoryEntryStatus(prev)
                {
                    BodyApproached = false,
                    BodyType = "Star",
                    BodyName = curStarSystem,
                    BodyID = -1,
                });

            case JournalTypeEnum.StartJump:
                if (prev.TravelState != TravelStateType.Hyperspace)     // checking we are into hyperspace, we could already be if in a series of jumps
                {
                    return(new HistoryEntryStatus(prev)
                    {
                        TravelState = TravelStateType.Hyperspace,
                    });
                }
                else
                {
                    return(prev);
                }

            case JournalTypeEnum.ShipyardBuy:
                return(new HistoryEntryStatus(prev)
                {
                    ShipID = -1,
                    ShipType = ((JournalShipyardBuy)je).ShipType      // BUY does not have ship id, but the new entry will that is written later - journals 8.34
                });

            case JournalTypeEnum.ShipyardNew:
                JournalShipyardNew jsnew = (JournalShipyardNew)je;
                return(new HistoryEntryStatus(prev)
                {
                    ShipID = jsnew.ShipId,
                    ShipType = jsnew.ShipType,
                    ShipTypeFD = jsnew.ShipFD,
                });

            case JournalTypeEnum.ShipyardSwap:
                JournalShipyardSwap jsswap = (JournalShipyardSwap)je;
                return(new HistoryEntryStatus(prev)
                {
                    ShipID = jsswap.ShipId,
                    ShipType = jsswap.ShipType,
                    ShipTypeFD = jsswap.ShipFD,
                });

            case JournalTypeEnum.JoinACrew:
                return(new HistoryEntryStatus(prev)
                {
                    OnCrewWithCaptain = ((JournalJoinACrew)je).Captain
                });

            case JournalTypeEnum.QuitACrew:
                return(new HistoryEntryStatus(prev)
                {
                    OnCrewWithCaptain = null
                });

            case JournalTypeEnum.Died:
                return(new HistoryEntryStatus(prev)
                {
                    BodyName = "Unknown",
                    BodyID = -1,
                    BodyType = "Unknown",
                    StationName = "Unknown",
                    StationType = "Unknown",
                    MarketId = null,
                    TravelState = TravelStateType.Docked,
                    OnCrewWithCaptain = null,
                    BodyApproached = false,         // we have to clear this, we can't tell if we are going back to another place..
                });

            case JournalTypeEnum.Loadout:
                var jloadout = (JournalLoadout)je;
                if (!ShipModuleData.IsSRV(jloadout.ShipFD))         // just double checking!
                {
                    return(new HistoryEntryStatus(prev)
                    {
                        ShipID = jloadout.ShipId,
                        ShipType = jloadout.Ship,
                        ShipTypeFD = jloadout.ShipFD,
                    });
                }
                else
                {
                    return(prev);
                }

            default:
                return(prev);
            }
        }
        public static HistoryEntryStatus Update(HistoryEntryStatus prev, JournalEntry je, string curStarSystem)
        {
            if (prev == null)
            {
                prev = new HistoryEntryStatus();
            }

            HistoryEntryStatus hes = prev;

            switch (je.EventTypeID)
            {
            case JournalTypeEnum.Location:
            {
                JournalLocation jloc = je as JournalLocation;

                bool locinstation = jloc.StationType.HasChars() || prev.StationType.HasChars();             // second is required due to alpha 4 stationtype being missing

                TravelStateType t = jloc.Docked ? (jloc.Multicrew == true ? TravelStateType.MulticrewDocked : TravelStateType.Docked) :
                                    (jloc.InSRV == true) ? (jloc.Multicrew == true ? TravelStateType.MulticrewSRV : TravelStateType.SRV) : // lat is pre 4.0 check
                                    jloc.Taxi == true ? TravelStateType.TaxiNormalSpace :                                                  // can't be in dropship, must be in normal space.
                                    jloc.OnFoot == true ? (locinstation ? TravelStateType.OnFootStarPort : TravelStateType.OnFootPlanet) :
                                    jloc.Latitude.HasValue ? (jloc.Multicrew == true ? TravelStateType.MulticrewLanded : TravelStateType.Landed) :
                                    jloc.Multicrew == true ? TravelStateType.MulticrewNormalSpace :
                                    TravelStateType.NormalSpace;

                hes = new HistoryEntryStatus(prev)             // Bodyapproach copy over we should be in the same state as last..
                {
                    TravelState    = t,
                    MarketId       = jloc.MarketID,
                    BodyID         = jloc.BodyID,
                    BodyType       = jloc.BodyType,
                    BodyName       = jloc.Body,
                    Wanted         = jloc.Wanted,
                    StationName    = jloc.StationName.Alt(jloc.Docked || locinstation ? jloc.Body : null),
                    StationType    = jloc.StationType.Alt(prev.StationType).Alt(jloc.Docked || locinstation ? jloc.BodyType : null),
                    StationFaction = jloc.StationFaction,                  // may be null
                };
                break;
            }

            case JournalTypeEnum.CarrierJump:
                var jcj = (je as JournalCarrierJump);
                hes = new HistoryEntryStatus(prev)         // we are docked on a carrier
                {
                    TravelState = TravelStateType.Docked,
                    MarketId    = jcj.MarketID,
                    BodyID      = jcj.BodyID,
                    BodyType    = jcj.BodyType,
                    BodyName    = jcj.Body,
                    Wanted      = jcj.Wanted,
                    StationName = jcj.StationName.Alt(null),           // if empty string, set to null
                    StationType = jcj.StationType.Alt(null),
                };
                break;

            case JournalTypeEnum.SupercruiseEntry:
            {
                var sc = je as JournalSupercruiseEntry;
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = sc.Taxi == true ? (prev.TravelState == TravelStateType.DropShipNormalSpace ? TravelStateType.DropShipSupercruise : TravelStateType.TaxiSupercruise):
                                  sc.Multicrew == true ? TravelStateType.MulticrewSupercruise :
                                  TravelStateType.Supercruise,

                    BodyName       = !prev.BodyApproached ? curStarSystem : prev.BodyName,
                    BodyType       = !prev.BodyApproached ? "Star" : prev.BodyType,
                    BodyID         = !prev.BodyApproached ? -1 : prev.BodyID,
                    BookedDropship = false,
                    StationName    = null,
                    StationType    = null,
                    StationFaction = null,         // to clear
                };
                break;
            }

            case JournalTypeEnum.SupercruiseExit:
            {
                JournalSupercruiseExit jsexit = (JournalSupercruiseExit)je;
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = jsexit.Taxi == true ? (prev.TravelState == TravelStateType.DropShipSupercruise ? TravelStateType.DropShipNormalSpace : TravelStateType.TaxiNormalSpace) :
                                  jsexit.Multicrew == true ? TravelStateType.MulticrewNormalSpace :
                                  TravelStateType.NormalSpace,

                    BodyName = (prev.BodyApproached) ? prev.BodyName : jsexit.Body,
                    BodyType = (prev.BodyApproached) ? prev.BodyType : jsexit.BodyType,
                    BodyID   = (prev.BodyApproached) ? prev.BodyID : jsexit.BodyID,
                };
                break;
            }

            case JournalTypeEnum.FSDJump:
            {
                var jfsd = (je as JournalFSDJump);
                hes = new HistoryEntryStatus(prev)
                {
                    // transition to XSupercruise
                    TravelState = jfsd.Taxi == true ? (prev.TravelState == TravelStateType.DropShipSupercruise || prev.TravelState == TravelStateType.DropShipNormalSpace ? TravelStateType.DropShipSupercruise : TravelStateType.TaxiSupercruise) :
                                  jfsd.Multicrew == true ? TravelStateType.MulticrewSupercruise :
                                  TravelStateType.Supercruise,
                    MarketId       = null,
                    BodyID         = -1,
                    BodyType       = "Star",
                    BodyName       = jfsd.StarSystem,
                    Wanted         = jfsd.Wanted,
                    StationName    = null,
                    StationType    = null,
                    StationFaction = null,         // to ensure
                    BodyApproached = false,
                };
                break;
            }

            case JournalTypeEnum.LoadGame:
                JournalLoadGame jlg = je as JournalLoadGame;

                hes = new HistoryEntryStatus(prev)
                {
                    OnCrewWithCaptain = null,         // can't be in a crew at this point
                    GameMode          = jlg.GameMode, // set game mode
                    Group             = jlg.Group,    // and group, may be empty
                    TravelState       = jlg.InSuit ? (prev.TravelState) :
                                        jlg.InTaxi ? TravelStateType.TaxiNormalSpace :
                                        jlg.InSRV ? TravelStateType.SRV :
                                        prev.TravelState != TravelStateType.Unknown ? prev.TravelState :
                                        TravelStateType.Docked,
                    ShipType       = jlg.InShip ? jlg.Ship : prev.ShipType,
                    ShipID         = jlg.InShip ? jlg.ShipId : prev.ShipID,
                    ShipTypeFD     = jlg.InShip ? jlg.ShipFD : prev.ShipTypeFD,
                    BookedDropship = false,     //  to ensure
                };
                break;


            case JournalTypeEnum.Docked:            // Docked not seen when in Taxi.
            {
                JournalDocked jdocked = (JournalDocked)je;
                //System.Diagnostics.Debug.WriteLine("{0} Docked {1} {2} {3}", jdocked.EventTimeUTC, jdocked.StationName, jdocked.StationType, jdocked.Faction);
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = jdocked.Taxi == true ? TravelStateType.TaxiDocked :
                                  jdocked.Multicrew == true ? TravelStateType.MulticrewDocked :
                                  TravelStateType.Docked,
                    MarketId       = jdocked.MarketID,
                    Wanted         = jdocked.Wanted,
                    StationName    = jdocked.StationName.Alt("Unknown"),
                    StationType    = jdocked.StationType.Alt("Station"),
                    StationFaction = jdocked.Faction,
                };
                break;
            }

            case JournalTypeEnum.Undocked:          // undocked not seen when in taxi
            {
                var ju = je as JournalUndocked;
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = ju.Taxi == true ? (prev.TravelState == TravelStateType.DropShipDocked ? TravelStateType.DropShipNormalSpace : TravelStateType.TaxiNormalSpace) :
                                  ju.Multicrew == true ? TravelStateType.MulticrewNormalSpace :
                                  TravelStateType.NormalSpace,
                    MarketId       = null,
                    StationName    = null,
                    StationType    = null,
                    StationFaction = null,         // to clear
                };
                break;
            }

            case JournalTypeEnum.Embark:            // foot-> SRV/Ship in multicrew or not.
            {
                var em = (JournalEmbark)je;

                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = em.SRV ? (em.Multicrew ? TravelStateType.MulticrewSRV : TravelStateType.SRV) :
                                  em.Taxi ? (prev.BookedDropship ? TravelStateType.DropShipDocked : TravelStateType.TaxiDocked) :
                                  em.Multicrew ? (prev.TravelState == TravelStateType.OnFootPlanet ? TravelStateType.MulticrewLanded : TravelStateType.MulticrewDocked):
                                  prev.TravelState == TravelStateType.OnFootPlanet ? TravelStateType.Landed:
                                  TravelStateType.Docked,
                    BookedDropship = false,
                    // update others tbd
                };
                break;
            }

            case JournalTypeEnum.Disembark:         // SRV/Ship -> on foot
                var disem = (JournalDisembark)je;

                bool instation = disem.StationType.HasChars() || prev.StationType.HasChars();

                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = disem.SRV ? TravelStateType.OnFootPlanet :
                                  disem.OnStation == true ?  TravelStateType.OnFootStarPort :
                                  disem.OnPlanet == true && instation ? TravelStateType.OnFootPlanetaryPort :
                                  TravelStateType.OnFootPlanet,
                    StationName = disem.StationType.HasChars() ? disem.StationName.Alt("Unknown") : prev.StationName,           // copying it over due to bug in alpha4
                    StationType = disem.StationType.HasChars() ? disem.StationType : prev.StationType,
                };
                break;

            case JournalTypeEnum.DropshipDeploy:
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.OnFootPlanet,
                };
                break;

            case JournalTypeEnum.LaunchSRV:
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.SRV
                };
                break;


            case JournalTypeEnum.DockSRV:
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState = TravelStateType.Landed
                };
                break;

            case JournalTypeEnum.Touchdown:
                // tbd do something with Body etc
                var td = (JournalTouchdown)je;
                if (td.PlayerControlled == true)            // can get this when not player controlled
                {
                    hes = new HistoryEntryStatus(prev)
                    {
                        TravelState = prev.TravelState == TravelStateType.MulticrewNormalSpace ? TravelStateType.MulticrewLanded : TravelStateType.Landed,
                    };
                }
                else
                {
                    hes = prev;
                }
                break;

            case JournalTypeEnum.Liftoff:
                // tbd do something with Body etc
                var loff = (JournalLiftoff)je;
                if (loff.PlayerControlled == true)             // can get this when not player controlled
                {
                    hes = new HistoryEntryStatus(prev)
                    {
                        TravelState = prev.TravelState == TravelStateType.MulticrewLanded ? TravelStateType.MulticrewNormalSpace : TravelStateType.NormalSpace,
                    };
                }
                else
                {
                    hes = prev;
                }
                break;


            case JournalTypeEnum.FighterDestroyed:
            case JournalTypeEnum.DockFighter:
            {
                if (prev.TravelState == TravelStateType.Fighter)
                {
                    hes = new HistoryEntryStatus(prev)
                    {
                        TravelState = TravelStateType.NormalSpace
                    };
                }
                break;
            }


            case JournalTypeEnum.LaunchFighter:
            {
                var j = je as JournalLaunchFighter;
                if (j.PlayerControlled)
                {
                    hes = new HistoryEntryStatus(prev)
                    {
                        TravelState = TravelStateType.Fighter,
                    };
                }
                break;
            }

            case JournalTypeEnum.ApproachBody:
                JournalApproachBody jappbody = (JournalApproachBody)je;
                hes = new HistoryEntryStatus(prev)
                {
                    BodyApproached = true,
                    BodyType       = jappbody.BodyType,
                    BodyName       = jappbody.Body,
                    BodyID         = jappbody.BodyID,
                };
                break;

            case JournalTypeEnum.ApproachSettlement:
                JournalApproachSettlement jappsettlement = (JournalApproachSettlement)je;
                hes = new HistoryEntryStatus(prev)
                {
                    BodyApproached = true,
                    BodyType       = jappsettlement.BodyType,
                    BodyName       = jappsettlement.BodyName,
                    BodyID         = jappsettlement.BodyID,
                };
                break;

            case JournalTypeEnum.LeaveBody:
                JournalLeaveBody jlbody = (JournalLeaveBody)je;
                hes = new HistoryEntryStatus(prev)
                {
                    BodyApproached = false,
                    BodyType       = "Star",
                    BodyName       = curStarSystem,
                    BodyID         = -1,
                };
                break;

            case JournalTypeEnum.ShipyardBuy:
                hes = new HistoryEntryStatus(prev)
                {
                    ShipID   = ulong.MaxValue,
                    ShipType = ((JournalShipyardBuy)je).ShipType      // BUY does not have ship id, but the new entry will that is written later - journals 8.34
                };
                break;

            case JournalTypeEnum.JoinACrew:
                hes = new HistoryEntryStatus(prev)
                {
                    OnCrewWithCaptain = ((JournalJoinACrew)je).Captain
                };
                break;

            case JournalTypeEnum.QuitACrew:
                hes = new HistoryEntryStatus(prev)
                {
                    OnCrewWithCaptain = null
                };
                break;

            case JournalTypeEnum.Died:
                hes = new HistoryEntryStatus(prev)
                {
                    TravelState       = TravelStateType.Unknown,
                    OnCrewWithCaptain = null,
                    BodyApproached    = false,      // we have to clear this, we can't tell if we are going back to another place..
                    BookedDropship    = false,
                };
                break;

            case JournalTypeEnum.Loadout:
                var jloadout = (JournalLoadout)je;
                if (ItemData.IsShip(jloadout.ShipFD))         // if ship, make a new entry
                {
                    hes = new HistoryEntryStatus(prev)
                    {
                        ShipID     = jloadout.ShipId,
                        ShipType   = jloadout.Ship,
                        ShipTypeFD = jloadout.ShipFD,
                    };
                }
                break;

            case JournalTypeEnum.ShipyardNew:
                JournalShipyardNew jsnew = (JournalShipyardNew)je;
                hes = new HistoryEntryStatus(prev)
                {
                    ShipID     = jsnew.ShipId,
                    ShipType   = jsnew.ShipType,
                    ShipTypeFD = jsnew.ShipFD,
                };
                break;

            case JournalTypeEnum.ShipyardSwap:
            {
                JournalShipyardSwap jsswap = (JournalShipyardSwap)je;
                hes = new HistoryEntryStatus(prev)
                {
                    ShipID     = jsswap.ShipId,
                    ShipType   = jsswap.ShipType,
                    ShipTypeFD = jsswap.ShipFD,
                };
                break;
            }

            case JournalTypeEnum.BookDropship:
                hes = new HistoryEntryStatus(prev)
                {
                    BookedDropship = true,
                };
                break;

            case JournalTypeEnum.CancelDropship:
            case JournalTypeEnum.BookTaxi:
                hes = new HistoryEntryStatus(prev)
                {
                    BookedDropship = false,
                };
                break;
            }

            return(hes);
        }