Esempio n. 1
0
    void Start()
    {
        GameplayData.Setup();

        world1InfoDisplay.Setup();
        world2InfoDisplay.Setup();
    }
Esempio n. 2
0
    public static GameplayData Load(string name)
    {
        Debug.Log("LOADING");

        if (File.Exists(GetFilePath(name)))
        {
            try
            {
                BinaryFormatter bf         = new BinaryFormatter();
                FileStream      file       = File.Open(GetFilePath(name), FileMode.Open);
                GameplayData    loadedGame = (GameplayData)bf.Deserialize(file);

                file.Close();

                return(loadedGame);
            }
            catch (SystemException e)
            {
                Debug.LogError(e);
                return(null);
            }
        }
        else
        {
            Debug.LogError("File doens't exit");
            return(null);
        }
    }
        internal void UpdatePlayerRemainingMovement(ActorData actor, bool send = true)
        {
            ActorTurnSM     turnSm          = actor.gameObject.GetComponent <ActorTurnSM>();
            ActorController actorController = actor.gameObject.GetComponent <ActorController>();
            ActorMovement   actorMovement   = actor.GetActorMovement();

            float movementCost = GetActorMovementCost(actor, out float lastStepCost);

            bool cannotExceedMaxMovement = GameplayData.Get()?.m_movementMaximumType == GameplayData.MovementMaximumType.CannotExceedMax;

            List <ActorTargeting.AbilityRequestData> abilityRequest = actor.TeamSensitiveData_authority.GetAbilityRequestData();
            bool abilitySet = !abilityRequest.IsNullOrEmpty() && abilityRequest[0].m_actionType != AbilityData.ActionType.INVALID_ACTION;

            actor.RemainingHorizontalMovement        = actorMovement.CalculateMaxHorizontalMovement() - movementCost;
            actor.RemainingMovementWithQueuedAbility = abilitySet ? actor.RemainingHorizontalMovement : actorMovement.CalculateMaxHorizontalMovement(true) - movementCost;
            actor.QueuedMovementAllowsAbility        = abilitySet ||
                                                       (cannotExceedMaxMovement
                    ? actor.RemainingMovementWithQueuedAbility >= 0
                    : actor.RemainingMovementWithQueuedAbility + lastStepCost > 0);

            Log.Info($"UpdatePlayerMovement:  Basic: {actor.m_postAbilityHorizontalMovement}/{actor.m_maxHorizontalMovement}, +",
                     $"Remaining: {actor.RemainingMovementWithQueuedAbility}/{actor.RemainingHorizontalMovement}, " +
                     $"Movement cost: {movementCost}, Ability set: {abilitySet}, Ability allowed: {actor.QueuedMovementAllowsAbility}, " +
                     $"Movement max type: {GameplayData.Get()?.m_movementMaximumType}");

            actorMovement.UpdateSquaresCanMoveTo();
            if (send)
            {
                actorController.CallRpcUpdateRemainingMovement(actor.RemainingHorizontalMovement, actor.RemainingMovementWithQueuedAbility);
            }
        }
Esempio n. 4
0
 public SharedData(PhysicsObjectsFactory objectsFactory, GameplayData gameplayData, PhysicsData physicsData, RenderData renderData, KeyState keys)
 {
     ObjectsFactory = objectsFactory;
     GameplayData   = gameplayData;
     PhysicsData    = physicsData;
     RenderData     = renderData;
     Keys           = keys;
 }
Esempio n. 5
0
    public static GameplayData Create()
    {
        GameplayData asset = ScriptableObject.CreateInstance <GameplayData> ();

        AssetDatabase.CreateAsset(asset, "Assets/GameDataFiles/GameplayData.asset");
        AssetDatabase.SaveAssets();
        return(asset);
    }
 public void DeleteMap()
 {
     if (selectedSavedGame != null)
     {
         GameplayData.Delete(selectedSavedGame.saveName);
         ClearGrid();
         FetchGrid();
         selectedSavedGame = null;
     }
 }
Esempio n. 7
0
    public void Setup()
    {
        WorldData worldData = GameplayData.GetWorldData(worldID);

        int bonusCount = BonusCollectableList.GetWorldCollectedCount(worldID);

        moonCountDisplay.text = bonusCount.ToString() + "/" + worldData.moonMax.ToString();

        collectableCountDisplay.text = "x" + worldData.collectCount;
    }
Esempio n. 8
0
    private void UpdateData()
    {
        PlayerHealth.SaveHealth();
        PlaytimeData.finishedStages++;
        CollectableDisplay.instance.SaveScore();
        BonusCollectableManager.SaveCollectedStates();

        WorldData worldData = GameplayData.GetWorldData();

        worldData.collectCount = CollectableDisplay.instance.Score;
    }
    public void OnLoadButtonClicked()
    {
        if (selectedSavedGame != null)
        {
            Debug.Log("Load " + selectedSavedGame.saveName);

            NextShiftLoaderData data = new NextShiftLoaderData(GameplayData.Load(selectedSavedGame.saveName));

            SceneSwitcher.Singleton.PrepareToLoadLevel(data);
        }
    }
Esempio n. 10
0
//        public class ObserverMessage : MessageBase
//        {
//            public Replay.Message Message;
//
//            public override void Serialize(NetworkWriter writer)
//            {
//                GeneratedNetworkCode._WriteMessage_Replay(writer, this.Message);
//            }
//
//            public override void Deserialize(NetworkReader reader)
//            {
//                this.Message = GeneratedNetworkCode._ReadMessage_Replay(reader);
//            }
//        }

        public void LaunchGame(bool spawnObjects = true)
        {
            MapLoader = new AssetLoader();
            MapLoader.LoadAssetBundle("Bundles/scenes/maps.bundle");
            MapLoader.LoadAsset(
                $"archive:/buildplayer-robotfactory_opu_gamemode/buildplayer-{GameConfig.Map.ToLower()}");
            MapLoader.ConstructCaches();

            AssetsLoader = new AssetLoader();
            AssetsLoader.LoadAsset("resources.assets");
            AssetsLoader.ConstructCaches();

            MiscLoader = new AssetLoader();
            MiscLoader.LoadAssetBundle("Bundles/scenes/frontend.bundle");
            MiscLoader.LoadAsset("archive:/buildplayer-options_ui/buildplayer-clientenvironmentsingletons");
            MiscLoader.ConstructCaches();

            if (!spawnObjects)
            {
                return;
            }

            SpawnObject(MiscLoader, "ApplicationSingletonsNetId", out _);
            SpawnObject(MiscLoader, "GameSceneSingletons", out var gameSceneSingletons);
            TheatricsManager  = gameSceneSingletons.GetComponent <TheatricsManager>();
            AbilityModManager = gameSceneSingletons.GetComponent <AbilityModManager>();
            SpawnObject(MiscLoader, "SharedEffectBarrierManager", out SharedEffectBarrierManager);
            SpawnObject(MiscLoader, "SharedActionBuffer", out SharedActionBuffer);
            SharedActionBuffer.Networkm_actionPhase = ActionBufferPhase.Done;

            SpawnScene(MapLoader, 1, out var commonGameLogic);
            InterfaceManager = commonGameLogic.GetComponent <InterfaceManager>();
            GameFlow         = commonGameLogic.GetComponent <GameFlow>();
//            MatchLogger = commonGameLogic.GetComponent<MatchLogger>();
            ServerCombatManager = commonGameLogic.GetComponent <ServerCombatManager>();
            ServerEffectManager = commonGameLogic.GetComponent <ServerEffectManager>();
            TeamStatusDisplay   = commonGameLogic.GetComponent <TeamStatusDisplay>();
            ServerActionBuffer  = commonGameLogic.GetComponent <ServerActionBuffer>();
            TeamSelectData      = commonGameLogic.GetComponent <TeamSelectData>();
            BarrierManager      = commonGameLogic.GetComponent <BarrierManager>();

            SpawnObject <Board, Board>(MapLoader, out Board);

            SpawnScene(MapLoader, 2, out BrushCoordinator);
            SpawnScene(MapLoader, 3, out var sceneGameLogic);
            GameFlowData       = sceneGameLogic.GetComponent <GameFlowData>();
            GameplayData       = sceneGameLogic.GetComponent <GameplayData>();
            SpoilsManager      = sceneGameLogic.GetComponent <SpoilsManager>();
            ObjectivePoints    = sceneGameLogic.GetComponent <ObjectivePoints>();
            SpawnPointManager  = sceneGameLogic.GetComponent <SpawnPointManager>();
            MatchObjectiveKill = sceneGameLogic.GetComponent <MatchObjectiveKill>();

            DumpNetObjects();
        }
Esempio n. 11
0
    public void LoadGameState()
    {
        GameplayData gameplayData = SaveLoadSystem_JamieG.LoadGameplay();

        // Load enemies
        GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
        foreach (var enemy in enemies)
        {
            if (!gameplayData.m_enemyIds.Contains(enemy.name))
            {
                enemy.SetActive(false);
            }
        }
    }
Esempio n. 12
0
    private void FetchGrid()
    {
        savedGames = GameplayData.GetMapsInDirectory();

        Debug.Log("maps count in directory -> " + savedGames.Length);

        for (int i = 0; i < savedGames.Length; i++)
        {
            Button            button       = Instantiate(buttonPrefab, grid).GetComponent <Button>();
            SavedGameSelector gameSelector = button.gameObject.AddComponent <SavedGameSelector>();
            gameSelector.saveName     = savedGames[i];
            gameSelector.loadGameMenu = this;
        }
    }
Esempio n. 13
0
    private void Start()
    {
        if (SceneSwitcher.Singleton.sceneLoaderData != null && SceneSwitcher.Singleton.sceneLoaderData.GetType() == typeof(NextShiftLoaderData))
        {
            NextShiftLoaderData data = SceneSwitcher.Singleton.sceneLoaderData as NextShiftLoaderData;
            title.text            += data.gameplayData.progressData.shiftsPassed;
            minedShale.text        = data.gameplayData.progressData.totalShaleMined.ToString();
            targetShaleAmount.text = data.gameplayData.scenarioData.goal.targetShaleAmount.ToString();
            shiftsRemaining.text   = (data.gameplayData.scenarioData.goal.numberOfShifts - data.gameplayData.progressData.shiftsPassed).ToString()
                                     + " out of "
                                     + data.gameplayData.scenarioData.goal.numberOfShifts;

            scenarioDone = data.gameplayData.progressData.shiftsPassed == data.gameplayData.scenarioData.goal.numberOfShifts;

            _data = data.gameplayData;
        }
    }
    public void EndShift()
    {
        LevelScenarioData scenarioData = ScenarioProgressController.Singleton.scenarioData;
        LevelProgressData progressData = ScenarioProgressController.Singleton.progressData;

        progressData.shiftsPassed++;

        MapData mapData = new MapData(scenarioData.name, BlockGridController.Singleton.grid);

        GameplayData gameplayData = new GameplayData(
            "Saved Game - " + scenarioData.name + " - Shift #" + (progressData.shiftsPassed + 1) + " - " + DateTime.Now.ToString("MM-dd-yyyy--HH-mm-ss"),
            mapData,
            scenarioData,
            progressData
            );

        SceneSwitcher.Singleton.ToResultsScene(new NextShiftLoaderData(gameplayData));
    }
Esempio n. 15
0
        public GameStartup()
        {
            const float dt = 1 / 60f;

            ClientSize       = new Size(900, 720);
            DoubleBuffered   = true;
            keys             = new KeyState();
            world            = new EcsWorld();
            worldEvents      = new EcsWorld();
            worldConstraints = new EcsWorld();
            gameplayData     = new GameplayData(new Vector2(0, -9.80665f));
            physicsData      = new PhysicsData(dt, 10, 4, 2);
            renderData       = new RenderData(ClientSize.Width, ClientSize.Height, 60f);
            var sharedData = new SharedData(new PhysicsObjectsFactory(world, worldConstraints), gameplayData, physicsData, renderData, keys);

            gameplaySystems = new EcsSystems(world, sharedData);
            gameplaySystems
            .AddWorld(worldEvents, PhysicsWorldNames.Events)
            .AddWorld(worldConstraints, PhysicsWorldNames.Constraints)
            .Add(new InitEnvironment())
            // .Add(new CreateSegments())
            .Add(new Grabber())
            .Inject()
            .Init();

            physicsSystems = new EcsSystems(world, physicsData);
            physicsSystems
            .AddWorld(worldEvents, PhysicsWorldNames.Events)
            .AddWorld(worldConstraints, PhysicsWorldNames.Constraints)
            // force generators
            .Add(new ApplyStaticGravity())     // custom one
            .Add(new UpdateSprings())
            // apply forces
            .Add(new IntegratePoses())
            // update bounding volumes
            .Add(new UpdateCirclesBV())
            .Add(new UpdateMeshesBV())
            // broad phase
            .Add(new BroadPhase())
            // narrow phase
            .Add(new ContactTesterCircleCircle())
            .Add(new ContactTesterCircleMesh())
            .Add(new ContactTesterCircleSegment())
            .Add(new ContactTesterMeshSegment())
            .Add(new ContactTesterCircleAABox())
            // solver phase
            .Add(new DynamicDefaultContactSolver <Dynamic, Dynamic>())
            .Add(new StaticDefaultContactSolver <Dynamic, Static>())
            // physics systems internally use PhysicsData,
            // but you can inject your own data for custom force generators
            .Inject(gameplayData)
            .Init();

            renderSystems = new EcsSystems(world, sharedData);
            renderSystems
            .AddWorld(worldEvents, PhysicsWorldNames.Events)
            .AddWorld(worldConstraints, PhysicsWorldNames.Constraints)
            .Add(new DrawVelocities())
            .Add(new DrawSegments())
            .Add(new DrawMeshes())
            .Add(new DrawAABoxes())
            .Add(new DrawSprings())
            // .Add(new DrawBoundingBoxes())
            .Add(new RenderMeshesMassCenter())
            .Inject(renderData)
            .Init();

            var timer = new Timer();

            timer.Interval = 16;
            timer.Tick    += GameLoop;
            timer.Start();
        }
Esempio n. 16
0
        /// <summary>
        /// Init this game and loads all the assets needed to receive players
        /// </summary>
        public void LaunchGame()
        {
            SetGameStatus(GameStatus.Launching);
            MapLoader = new AssetLoader();
            MapLoader.LoadAssetBundle("Bundles/scenes/maps.bundle");
            MapLoader.LoadAsset($"archive:/buildplayer-robotfactory_opu_gamemode/buildplayer-{GameConfig.Map.ToLower()}");

            MapLoader.ConstructCaches();


            AssetsLoader = new AssetLoader();
            AssetsLoader.LoadAsset("resources.assets");
            AssetsLoader.ConstructCaches();

            MiscLoader = new AssetLoader();
            MiscLoader.LoadAssetBundle("Bundles/scenes/frontend.bundle");
            MiscLoader.LoadAsset("archive:/buildplayer-options_ui/buildplayer-clientenvironmentsingletons");
            MiscLoader.ConstructCaches();

            SpawnObject(MiscLoader, "ApplicationSingletonsNetId", out _);
            SpawnObject(MiscLoader, "GameSceneSingletons", out var gameSceneSingletons);
            TheatricsManager  = gameSceneSingletons.GetComponent <TheatricsManager>();
            AbilityModManager = gameSceneSingletons.GetComponent <AbilityModManager>();
            SpawnObject(MiscLoader, "SharedEffectBarrierManager", out SharedEffectBarrierManager);
            SpawnObject(MiscLoader, "SharedActionBuffer", out SharedActionBuffer);
            SharedActionBuffer.Networkm_actionPhase = ActionBufferPhase.Done;

            SpawnScene(MapLoader, 1, out var commonGameLogic);
            InterfaceManager    = commonGameLogic.GetComponent <InterfaceManager>();
            GameFlow            = commonGameLogic.GetComponent <GameFlow>();
            MatchLogger         = commonGameLogic.GetComponent <MatchLogger>();
            ServerCombatManager = commonGameLogic.GetComponent <ServerCombatManager>();
            ServerEffectManager = commonGameLogic.GetComponent <ServerEffectManager>();
            TeamStatusDisplay   = commonGameLogic.GetComponent <TeamStatusDisplay>();
            ServerActionBuffer  = commonGameLogic.GetComponent <ServerActionBuffer>();
            TeamSelectData      = commonGameLogic.GetComponent <TeamSelectData>();
            BarrierManager      = commonGameLogic.GetComponent <BarrierManager>();

            SpawnObject <Board, Board>(MapLoader, out Board);
            SpawnScene(MapLoader, 2, out BrushCoordinator);
            SpawnScene(MapLoader, 3, out var sceneGameLogic);

            GameFlowData       = sceneGameLogic.GetComponent <GameFlowData>();
            GameplayData       = sceneGameLogic.GetComponent <GameplayData>();
            SpoilsManager      = sceneGameLogic.GetComponent <SpoilsManager>();
            ObjectivePoints    = sceneGameLogic.GetComponent <ObjectivePoints>();
            SpawnPointManager  = sceneGameLogic.GetComponent <SpawnPointManager>();
            MatchObjectiveKill = sceneGameLogic.GetComponent <MatchObjectiveKill>();

            PrintAllNetworkGameObjects();

            foreach (LobbyPlayerInfo playerInfo in TeamInfo.TeamPlayerInfo)
            {
                // We use the ReadyState here to indicate wheter a player or bot finished loading the match
                if (playerInfo.IsNPCBot)
                {
                    playerInfo.ReadyState = ReadyState.Ready; // Bots are marked as ready as they don't have to load anything
                }
                else
                {
                    playerInfo.ReadyState = ReadyState.Unknown; // Unknown means it is loading
                }
            }

            SetGameStatus(GameStatus.Launched);
        }
Esempio n. 17
0
    // Saves the current state of the game into the Gameplay.save file
    public static void SaveGameplay(int currentLevel, GameObject[] enemies, GameObject[] doors)
    {
        GameplayData gameplayData = new GameplayData(currentLevel, enemies, doors);

        SaveToFile(GameplayFile, gameplayData);
    }
 public NextShiftLoaderData(GameplayData gameplayData)
 {
     this.gameplayData = gameplayData;
 }
        private BoardSquarePathInfo BackOff(ActorData actor, BoardSquarePathInfo pathEnd, HashSet <GridPos> occupiedSquares)
        {
            if (actor == null)
            {
                Log.Error($"Backoff failed because actor is null!");
                return(null);
            }
            Log.Info($"Calculating backoff for {actor.DisplayName}");

            BoardSquare dest = pathEnd.prev?.square ?? pathEnd.square;

            if (occupiedSquares.Contains(dest.GetGridPosition()))
            {
                bool diagMovementAllowed       = GameplayData.Get().m_diagonalMovement != GameplayData.DiagonalMovement.Disabled;
                List <BoardSquare>  neighbours = new List <BoardSquare>(8);
                Queue <BoardSquare> candidates = new Queue <BoardSquare>();
                candidates.Enqueue(pathEnd.square);
                while (candidates.Count > 0)
                {
                    BoardSquare s = candidates.Dequeue();
                    if (!occupiedSquares.Contains(s.GetGridPosition()))
                    {
                        dest = s;
                        break;
                    }

                    neighbours.Clear();
                    if (!diagMovementAllowed)
                    {
                        Board.Get().GetStraightAdjacentSquares(s.x, s.y, ref neighbours);
                    }
                    else
                    {
                        Board.Get().GetAllAdjacentSquares(s.x, s.y, ref neighbours);
                    }
                    neighbours.Sort(delegate(BoardSquare a, BoardSquare b)
                    {
                        return(dest.HorizontalDistanceInWorldTo(a).CompareTo(dest.HorizontalDistanceInWorldTo(b)));
                    });
                    foreach (var n in neighbours)
                    {
                        if (n.IsBoardHeight())
                        {
                            candidates.Enqueue(n);
                        }
                    }
                }
            }

            if (occupiedSquares.Contains(dest.GetGridPosition()))
            {
                Log.Error($"Backoff failed to find a free square for {actor.DisplayName}!");
            }
            occupiedSquares.Add(dest.GetGridPosition());

            BoardSquarePathInfo result = actor.GetActorMovement().BuildPathTo_IgnoreBarriers(pathEnd.square, dest);

            result.heuristicCost         += pathEnd.heuristicCost; // not actually correct but shouldn't matter
            result.moveCost              += pathEnd.moveCost;
            result.m_moverBumpedFromClash = true;
            return(result);
        }