public void ShowContractObjective(ContractObjectiveGameLogic contractObjectiveGameLogic)
 {
     contractObjectiveGameLogic.LogObjective("Contract Objective Shown");
     contractObjectiveGameLogic.displayToUser = true;
     AccessTools.Field(typeof(ContractObjectiveGameLogic), "currentObjectiveStatus").SetValue(contractObjectiveGameLogic, ObjectiveStatus.Active);
     EncounterLayerParent.EnqueueLoadAwareMessage(new ObjectiveUpdated(contractObjectiveGameLogic.encounterObjectGuid));
 }
Exemple #2
0
        static void Prefix(EncounterLayerParent __instance)
        {
            Main.Logger.Log($"[EncounterLayerParentInitializeContractPatch Prefix] Patching InitializeContract");
            MissionControl.Instance.InitSceneData();
            MissionControl encounterManager = MissionControl.Instance;

            MissionControl.Instance.RunEncounterRules(LogicBlock.LogicType.ENCOUNTER_MANIPULATION);
        }
        static void Prefix(EncounterLayerParent __instance, MessageCenterMessage message)
        {
            Main.Logger.Log($"[EncounterLayerParentInitializeContractPatch Prefix] Patching InitializeContract");
            InitializeContractMessage initializeContractMessage = message as InitializeContractMessage;
            CombatGameState           combat = initializeContractMessage.combat;
            Contract activeContract          = combat.ActiveContract;

            GizmoManager.GetInstance().SetContract(activeContract);
        }
        protected override void SpawnUnits(bool offScreen)
        {
            base.SpawnUnits(offScreen);

            if (this.teamDefinitionGuid == EncounterRules.PLAYER_TEAM_ID)
            {
                EncounterLayerParent.EnqueueLoadAwareMessage(new RefreshPortraitsMessage());
            }
        }
Exemple #5
0
        static void Prefix(EncounterLayerParent __instance)
        {
            Main.Logger.Log($"[EncounterLayerParentFirstTimeInitializationPatch Prefix] Patching FirstTimeInitialization");
            MissionControl EncounterManager = MissionControl.Instance;

            if (EncounterManager.IsContractValid)
            {
                EncounterManager.RunEncounterRules(LogicBlock.LogicType.SCENE_MANIPULATION);
            }
        }
        static void Prefix(EncounterLayerParent __instance)
        {
            Main.Logger.Log($"[EncounterLayerParentFirstTimeInitializationPatch Prefix] Patching FirstTimeInitialization");
            MissionControl EncounterManager = MissionControl.Instance;

            if (EncounterManager.IsContractValid)
            {
                UnityGameInstance.BattleTechGame.MessageCenter.PublishMessage(new BeforeSceneManipulationMessage());
                EncounterManager.RunEncounterRules(LogicBlock.LogicType.SCENE_MANIPULATION);
            }
        }
        private EncounterLayerData GetActiveEncounter()
        {
            if (EncounterLayerData)
            {
                return(EncounterLayerData);
            }

            Contract           activeContract             = UnityGameInstance.BattleTechGame.Combat.ActiveContract;
            string             encounterObjectGuid        = activeContract.encounterObjectGuid; // Contract Type GUID
            EncounterLayerData selectedEncounterLayerData = EncounterLayerParent.GetLayerByGuid(encounterObjectGuid);

            return(selectedEncounterLayerData);
        }
Exemple #8
0
    public static void LoadMapData(this EncounterLayerData layerData, EncounterLayerIdentifier encounterLayerIdentifier, DataManager dataManager)
    {
        EncounterLayerParent component       = MissionControl.MissionControl.Instance.EncounterLayerParent;
        MapMetaDataExporter  mapMetaExporter = component.GetComponent <MapMetaDataExporter>();

        AccessTools.Method(typeof(MapMetaDataExporter), "LoadMapMetaDataOnly").Invoke(mapMetaExporter, new object[] { UnityGameInstance.BattleTechGame.Combat.MapMetaData, dataManager });

        MapMetaData     mapMetaData     = mapMetaExporter.mapMetaData;
        InclineMeshData inclineMeshData = mapMetaExporter.inclineMeshData;

        string encounterLayerIdentifierPath = encounterLayerIdentifier.path;
        string encounterLayerDataName       = MapMetaDataExporter.GetEncounterLayerDataName(encounterLayerIdentifier.name);

        MissionControl.Main.LogDebug("[LoadMapData] Borrowing Map Data form Layer Data " + encounterLayerDataName);

        encounterLayerIdentifierPath = dataManager.ResourceLocator.EntryByID(encounterLayerDataName, BattleTechResourceType.LayerData, false).FilePath;
        byte[]             data        = File.ReadAllBytes(encounterLayerIdentifierPath);
        EncounterLayerData layerByGuid = layerData;

        Serializer.Deserialize <EncounterLayerData>(data, SerializationTarget.Exported, TargetMaskOperation.HAS_ANY, layerByGuid);
        layerByGuid.ReattachReferences();
        using (SerializationStream serializationStream = new SerializationStream(File.ReadAllBytes(encounterLayerIdentifierPath.Replace(".bin", "_RaycastInfo.bin")))) {
            layerByGuid.LoadRaycastInfo(serializationStream);
        }
        int length  = mapMetaData.mapTerrainDataCells.GetLength(1);
        int length2 = mapMetaData.mapTerrainDataCells.GetLength(0);

        for (int i = 0; i < length; i++)
        {
            for (int j = 0; j < length2; j++)
            {
                mapMetaData.mapTerrainDataCells[i, j].MapEncounterLayerDataCell = layerByGuid.mapEncounterLayerDataCells[i, j];
                mapMetaData.mapTerrainDataCells[i, j].UpdateCachedValues();
            }
        }
        string inclineMeshPathFromEncounterLayerDataPath = encounterLayerIdentifierPath.Replace(".bin", "_InclineMesh.IMS");

        inclineMeshData = new InclineMeshData();
        if (inclineMeshData.LoadFromPath(inclineMeshPathFromEncounterLayerDataPath))
        {
            inclineMeshData.mapMetaData = mapMetaData;
            layerByGuid.inclineMeshData = inclineMeshData;
        }
        else
        {
            layerByGuid.inclineMeshData = null;
        }

        mapMetaExporter.mapTags = new TagSet(mapMetaData.mapTags);
        MissionControl.Main.LogDebug("[LoadMapData] Load Complete");
    }
        static void Prefix(LanceSpawnerGameLogic __instance)
        {
            // Main.LogDebug($"[LanceSpawnerGameLogicOnUnitSpawnCompletePatch] Patching Prefix");
            if (HasLanceSpawnCompleted(__instance))
            {
                LanceSpawnedMessage lanceSpawnedMessage = new LanceSpawnedMessage(__instance.encounterObjectGuid, __instance.LanceGuid);
                EncounterLayerParent.EnqueueLoadAwareMessage(lanceSpawnedMessage);

                /*
                 * // From the unit spawn message - might need a similar one for lance spawning to interrupt
                 * if (this.triggerInterruptPhaseOnSpawn) {
                 * abstractActor.IsInterruptActor = true;
                 * base.Combat.StackManager.InsertInterruptPhase(team.GUID, unitSpawnedMessage.messageIndex);
                 * }
                 */
            }
        }
Exemple #10
0
        private void DestroyBuildingsUnderLanceSpawns(UnitSpawnPointGameLogic[] unitSpawns, BuildingRepresentation[] buildings, float radius)
        {
            foreach (UnitSpawnPointGameLogic unitSpawn in unitSpawns)
            {
                Vector3 position = unitSpawn.transform.position;

                foreach (BuildingRepresentation building in buildings)
                {
                    if (!building.IsDead)
                    {
                        if (position.DistanceFlat(building.transform.position) <= Radius)
                        {
                            EncounterLayerParent.EnqueueLoadAwareMessage(new DestroyActorMessage(EncounterLayerData.MapLogicGuid, building.parentCombatant.GUID));
                        }
                    }
                }
            }
        }
        public void GenerateEncounterLayerBuildingData()
        {
            Main.Logger.LogDebug($"[EncounterDataManager.GenerateEncounterLayerBuildingData] Generating building data");
            Terrain terrain            = Terrain.activeTerrain;
            float   terrainZSize       = terrain.terrainData.size.z;
            float   terrainXSize       = terrain.terrainData.size.x;
            Vector3 terrainPosition    = terrain.transform.position;
            float   halfMapCellSize    = (float)MapMetaDataExporter.cellSize / 2f;
            int     halfMapCellSizeInt = MapMetaDataExporter.cellSize / 2;
            EncounterLayerParent encounterLayerParent = MissionControl.Instance.EncounterLayerParent;
            EncounterLayerData   encounterLayerData   = MissionControl.Instance.EncounterLayerData;
            MapMetaDataExporter  mapMetaExporter      = encounterLayerParent.GetComponent <MapMetaDataExporter>();
            MapMetaData          mapMetaData          = UnityGameInstance.BattleTechGame.Combat.MapMetaData;
            Vector3 raycastOrigin = new Vector3(0f, 1000f, 0f);

            // Lookups
            Dictionary <string, int>    regionRaycastHits         = new Dictionary <string, int>();
            List <RegionGameLogic>      regionGameObjectList      = new List <RegionGameLogic>();
            List <ObstructionGameLogic> obstructionGameObjectList = new List <ObstructionGameLogic>();

            // Marks only the ObstructionGameLogic objects for ray tracing for performance reasons
            AccessTools.Method(typeof(MapMetaDataExporter), "MarkCellsForRaycasting").Invoke(mapMetaExporter, new object[] { mapMetaData.mapTerrainDataCells, (int)terrain.transform.position.x, (int)terrain.transform.position.z });

            // TODO: Maybe wipe region building lists. Not sure if I really need/want this yet
            RegionGameLogic[] componentsInChildren = encounterLayerData.GetComponentsInChildren <RegionGameLogic>();
            for (int i = 0; i < componentsInChildren.Length; i++)
            {
                componentsInChildren[i].InitRegionForRayCasting();
            }

            // Iterate over the Z cell range
            for (float i = halfMapCellSize; i < terrainZSize; i += (float)MapMetaDataExporter.cellSize)
            {
                int zCellIndex = (int)i / MapMetaDataExporter.cellSize;

                // Iterate over the X cell range
                for (float j = halfMapCellSize; j < terrainXSize; j += (float)MapMetaDataExporter.cellSize)
                {
                    int xCellIndex = (int)j / MapMetaDataExporter.cellSize;

                    MapEncounterLayerDataCell mapEncounterLayerDataCell = new MapEncounterLayerDataCell();
                    if (mapMetaData.mapTerrainDataCells[zCellIndex, xCellIndex].doRayCast)
                    {
                        int hitIndex = 0;
                        regionRaycastHits.Clear();
                        regionGameObjectList.Clear();
                        obstructionGameObjectList.Clear();

                        for (int k = -halfMapCellSizeInt; k < halfMapCellSizeInt; k++)
                        {
                            raycastOrigin.z = i + (float)k + terrainPosition.z;

                            for (int l = -halfMapCellSizeInt; l < halfMapCellSizeInt; l++)
                            {
                                raycastOrigin.x = j + (float)l + terrainPosition.x;

                                RaycastHit[] raycastHits          = Physics.RaycastAll(raycastOrigin, Vector3.down);
                                List <ObstructionGameLogic> list3 = new List <ObstructionGameLogic>();

                                // Go through all the raycasts at Z,X of the terrain by cell size (middle of cell)
                                // Then find any regions hit, record the number of hits/cells the region has
                                for (int m = 0; m < raycastHits.Length; m++)
                                {
                                    RegionGameLogic regionGameLogic = raycastHits[m].transform.GetComponent <RegionGameLogic>();
                                    if (regionGameLogic != null)
                                    {
                                        if (!regionRaycastHits.ContainsKey(regionGameLogic.encounterObjectGuid))
                                        {
                                            regionRaycastHits[regionGameLogic.encounterObjectGuid] = 1;
                                        }
                                        else
                                        {
                                            string encounterObjectGuid = regionGameLogic.encounterObjectGuid;
                                            regionRaycastHits[encounterObjectGuid]++;
                                        }

                                        // Cache the region in the lookup
                                        if (!regionGameObjectList.Contains(regionGameLogic))
                                        {
                                            regionGameObjectList.Add(regionGameLogic);
                                        }
                                    }

                                    ObstructionGameLogic obstructionGameLogicInParent = raycastHits[m].transform.GetComponentInParent <ObstructionGameLogic>();
                                    if (obstructionGameLogicInParent != null && raycastHits[m].point.y > mapMetaData.mapTerrainDataCells[zCellIndex, xCellIndex].terrainHeight)
                                    {
                                        if (obstructionGameLogicInParent.IsBuildingHitAddWorthy)
                                        {
                                            if (!obstructionGameObjectList.Contains(obstructionGameLogicInParent))
                                            {
                                                obstructionGameObjectList.Add(obstructionGameLogicInParent);
                                            }
                                        }

                                        Vector3            normal             = raycastHits[m].normal;
                                        BuildingRaycastHit buildingRaycastHit = new BuildingRaycastHit {
                                            buildingSteepness = 90f - 57.29578f * Mathf.Atan2(normal.y, Mathf.Sqrt(normal.x * normal.x + normal.z * normal.z)),
                                            buildingHeight    = raycastHits[m].point.y,
                                            buildingGuid      = obstructionGameLogicInParent.encounterObjectGuid,
                                            hitIndex          = hitIndex
                                        };
                                        mapEncounterLayerDataCell.AddBuildingHit(buildingRaycastHit);
                                    }
                                }
                                hitIndex++;
                            }
                        }

                        // For all the regions detected, if it exists in 10 or more cells - add the region to the map encounter layer data (this is vanilla... why?!)
                        // And all all obstruction games logics to the region
                        foreach (RegionGameLogic regionGameLogic in regionGameObjectList)
                        {
                            if (regionRaycastHits[regionGameLogic.encounterObjectGuid] >= 10)
                            {
                                mapEncounterLayerDataCell.AddRegion(regionGameLogic);
                                foreach (ObstructionGameLogic obstructionGameLogic in obstructionGameObjectList)
                                {
                                    regionGameLogic.AddBuildingGuidToRegion(obstructionGameLogic.encounterObjectGuid);
                                }
                            }
                        }
                        mapEncounterLayerDataCell.AverageTheBuildingHits();
                        mapEncounterLayerDataCell.SortBuildingListByHeight();
                    }

                    encounterLayerData.mapEncounterLayerDataCells[zCellIndex, xCellIndex] = mapEncounterLayerDataCell;
                    encounterLayerData.mapEncounterLayerDataCells[zCellIndex, xCellIndex].relatedTerrainCell = mapMetaData.mapTerrainDataCells[zCellIndex, xCellIndex];
                    mapMetaData.mapTerrainDataCells[zCellIndex, xCellIndex].MapEncounterLayerDataCell        = mapEncounterLayerDataCell;
                }
            }
        }
Exemple #12
0
        public static void Postfix(EncounterLayerParent __instance, CombatGameState combat)
        {
            Mod.Log.Trace?.Write($"TD:IFSPT entered");

            TurnDirector_OnEncounterBegin.IsFromSave = true;
        }