public StatKeeper()
{
Logger.log.Info("2 New statkeeper active.");
CutChart = new GameObject();
Object.DontDestroyOnLoad(CutChart);
//Utilities.SetGameObjectTransform(CutChart, Vector3.zero, Quaternion.identity, Vector3.zero);
CutChart.SetActive(true);
//CutChart.transform.position = Vector3.zero;
CutChart.transform.localScale = Vector3.one;
//CutChart.transform.rotation = Quaternion.identity;
CutChart.transform.SetPositionAndRotation(Vector3.zero, gridRotation);
CutChart.transform.localScale = Vector3.zero;
cutPoints = new List <GameObject>();
_scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().First();
_sceneData = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData;
BOSC = Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().First();
songDifficulty = _sceneData.difficultyBeatmap.difficulty.ToString().ToLower();
songName = _sceneData.difficultyBeatmap.level.songName;
songNoteCount = _sceneData.difficultyBeatmap.beatmapData.cuttableNotesType;
GetScoreController().noteWasMissedEvent += OnNoteMissed;
GetBOM().noteWasCutEvent += OnNoteCut;
//BSEvents.songPaused += OnPause;
//BSEvents.songUnpaused += UnPause;
}
internal static void Prefix(ref GameplayCoreInstaller __instance, ref IConnectedPlayer ____connectedPlayer, ref GameplayCoreSceneSetupData ____sceneSetupData)
{
var mib = __instance as MonoInstallerBase;
var Container = SiraUtil.Accessors.GetDiContainer(ref mib);
ExtendedPlayerManager exPlayerManager = Container.Resolve <ExtendedPlayerManager>();
ExtendedPlayer? exPlayer = exPlayerManager.GetExtendedPlayer(____connectedPlayer);
ExtendedPlayer? hostPlayer = exPlayerManager.GetExtendedPlayer(Container.Resolve <IMultiplayerSessionManager>().connectionOwner);
GameplayModifiers?newModifiers;
if (____connectedPlayer.HasState("modded") && MPState.FreeModEnabled && exPlayer?.mpexVersion >= _minVersionFreeMod)
{
newModifiers = exPlayer.lastModifiers;
}
else
{
newModifiers = hostPlayer?.lastModifiers;
}
if (newModifiers != null)
{
____sceneSetupData = new GameplayCoreSceneSetupData(
____sceneSetupData.difficultyBeatmap,
____sceneSetupData.previewBeatmapLevel,
newModifiers,
____sceneSetupData.playerSpecificSettings,
____sceneSetupData.practiceSettings,
____sceneSetupData.useTestNoteCutSoundEffects,
____sceneSetupData.environmentInfo,
____sceneSetupData.colorScheme
);
}
}
/// <summary>
/// Performs the transformation
/// </summary>
public IEnumerator TransformBeatMap()
{
yield return(new WaitForSecondsRealtime(0.1f));
if (this.NoArrowsOption && BS_Utils.Plugin.LevelData.IsSet)
{
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
var beatmap = data.difficultyBeatmap;
string characteristic = beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.characteristicName;
// Logging.Info($"Characteristic: {characteristic}");
if (characteristic == ("One Saber") || characteristic == ("No Arrows"))
{
// Do not transform for One Saber or legitimate No Arrows mode
Logging.Info($"Cannot transform song: {beatmap.level.songName} due to being a One Saber or No Arrows map");
yield break;
}
Logging.Info("Disabling submission on NoArrowsOption turned on.");
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission("NoArrowsRandom");
var gameplayCore = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().FirstOrDefault();
if (gameplayCore == null)
{
yield break;
}
// Applying NoArrowsRandom transformation
Logging.Info($"Transforming song: {beatmap.level.songName}");
var transformedBeatmap = BeatmapDataNoArrowsTransform.CreateTransformedData(beatmap.beatmapData, true);
var beatmapDataModel = gameplayCore.GetPrivateField <BeatmapDataModel>("_beatmapDataModel");
beatmapDataModel.SetPrivateField("_beatmapData", transformedBeatmap);
}
}
// Using the magical power of Zenject™, we magically find ourselves with an instance of
// our HUDConfigModel and the CoreGameHUDController.
internal CanvasUtility(HUDConfigModel hudConfig,
MainConfigModel mainConfig,
[Inject(Optional = true)] GameplayCoreSceneSetupData data,
[Inject(Optional = true)] CoreGameHUDController coreGameHUD)
{
this.mainConfig = mainConfig;
if (coreGameHUD != null)
{
var comboPos = coreGameHUD.GetComponentInChildren <ComboUIController>().transform.position;
hudWidth = Mathf.Abs(comboPos.x);
hudHeight = comboPos.y;
hudDepth = comboPos.z;
energyCanvas = EnergyPanelGO(ref coreGameHUD).GetComponent <Canvas>();
// Hide Canvas and Multiplier if needed
if (mainConfig.HideCombo)
{
HideBaseGameHUDElement <ComboUIController>(coreGameHUD);
}
if (mainConfig.HideMultiplier)
{
HideBaseGameHUDElement <ScoreMultiplierUIController>(coreGameHUD);
}
}
RefreshAllCanvases(hudConfig, data, coreGameHUD);
}
static bool Prefix(ref GameCoreSceneSetup __instance, ref GameplayCoreSceneSetupData ____sceneSetupData)
{
IDifficultyBeatmap difficultyBeatmap = ____sceneSetupData.difficultyBeatmap;
IReadOnlyList <BeatmapEventData> beatmapEventData = difficultyBeatmap.beatmapData.beatmapEventsData;
SpawnRotationProcessor rotProcessor = new SpawnRotationProcessor();
bool is360 = false;
foreach (BeatmapEventData beatmapEvent in beatmapEventData)
{
if (beatmapEvent.type != BeatmapEventType.Event14 && beatmapEvent.type != BeatmapEventType.Event15)
{
continue;
}
if (rotProcessor.RotationForEventValue(beatmapEvent.value) != 0)
{
is360 = true;
break;
}
}
if (!is360)
{
IPAUtils.SetProperty <BeatmapData, int>(difficultyBeatmap.beatmapData, "spawnRotationEventsCount", 0);
}
return(true);
}
internal static void Prefix(ref GameplayCoreInstaller __instance, ref GameplayCoreSceneSetupData ____sceneSetupData)
{
var container = GetContainer(__instance);
var settings = container.Resolve <MiscSettings>();
if (settings.BPMFixEnabled)
{
bool actually360 = false;
var data = ____sceneSetupData.difficultyBeatmap.beatmapData.beatmapEventsData;
var spawnRotationProcessor = new SpawnRotationProcessor();
for (int i = 0; i < data.Count; i++)
{
var bmEvent = data[i];
if (bmEvent.type == BeatmapEventType.Event14 || bmEvent.type == BeatmapEventType.Event15)
{
if (spawnRotationProcessor.RotationForEventValue(bmEvent.value) != 0)
{
actually360 = true;
}
}
}
if (!actually360)
{
var beatmapData = ____sceneSetupData.difficultyBeatmap.beatmapData;
SetRotationCount(ref beatmapData, 0);
}
}
}
private async void ReloadBeatmap()
{
string filePath = Path.Combine(_currentLevel.customLevelPath, _currentDiffBeatmap.beatmapFilename);
string leveljson = File.ReadAllText(filePath);
//Load new beatmapdata asynchronously
BeatmapData newBeatmap = await _levelLoader.LoadBeatmapDataAsync(_currentLevel.customLevelPath, _currentDiffBeatmap.beatmapFilename, _currentLevel.standardLevelInfoSaveData, _cancelSource.Token);
GameplayCoreSceneSetupData gameSetup = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData;
EnvironmentEffectsFilterPreset environmentEffectsFilterPreset = ((BeatmapDifficulty)(Enum.Parse(typeof(BeatmapDifficulty), _currentDiffBeatmap.difficulty)) == BeatmapDifficulty.ExpertPlus) ? gameSetup.playerSpecificSettings.environmentEffectsFilterExpertPlusPreset : gameSetup.playerSpecificSettings.environmentEffectsFilterDefaultPreset;
newBeatmap = (BeatmapData)BeatmapDataTransformHelper.CreateTransformedBeatmapData(newBeatmap, _currentLevel, gameSetup.gameplayModifiers, gameSetup.practiceSettings, gameSetup.playerSpecificSettings.leftHanded, environmentEffectsFilterPreset, gameSetup.environmentInfo.environmentIntensityReductionOptions);
//Hotswap Beatmap
ResetTimeSync();
DestroyObjects();
ResetNoteCutSoundEffects();
_callbackController.SetField("_spawningStartTime", _songStartTime);
_callbackController.SetNewBeatmapData(newBeatmap);
//Unpause
if (_pauseController.GetField <bool>("_paused"))
{
CheckPracticePlugin();
_pauseController.HandlePauseMenuManagerDidPressContinueButton();
}
_queuedLoad = false;
}
internal static void Postfix(ref GameplayCoreInstaller __instance, ref GameplayCoreSceneSetupData ____sceneSetupData)
{
var container = GetContainer(__instance);
var settings = container.Resolve <MiscSettings>();
if (settings.BPMFixEnabled)
{
bool actually360 = false;
foreach (var item in ____sceneSetupData.transformedBeatmapData.allBeatmapDataItems)
{
if (item is SpawnRotationBeatmapEventData rotation)
{
if (rotation.rotation != 0)
{
actually360 = true;
break;
}
}
}
if (!actually360)
{
container.Unbind <BeatLineManager>();
}
}
}
// Using the magical power of Zenject™, we magically find ourselves with an instance of
// our HUDConfigModel and the CoreGameHUDController.
internal CanvasUtility(HUDConfigModel hudConfig,
MainConfigModel mainConfig,
[Inject(Optional = true)] GameplayCoreSceneSetupData data,
[Inject(Optional = true)] CoreGameHUDController coreGameHUD)
{
this.mainConfig = mainConfig;
if (coreGameHUD != null)
{
energyCanvas = EnergyPanelGO(ref coreGameHUD).GetComponent <Canvas>();
// Hide Canvas and Multiplier if needed
if (mainConfig.HideCombo)
{
HideBaseGameHUDElement <ComboUIController>(coreGameHUD);
}
if (mainConfig.HideMultiplier)
{
HideBaseGameHUDElement <ScoreMultiplierUIController>(coreGameHUD);
}
}
if (data != null)
{
HUDType = GetGameplayCoreHUDTypeForEnvironmentSize(data.environmentInfo.environmentSizeData.width);
}
RefreshAllCanvases(hudConfig, data, coreGameHUD);
}
internal static void Prefix(GameplayCoreInstaller __instance, ref GameplayCoreSceneSetupData ____sceneSetupData)
{
var mib = __instance as MonoInstallerBase;
var Container = Accessors.GetDiContainer(ref mib);
Container.BindInterfacesAndSelfTo <Submission>().AsSingle();
}
private void Init(CountersData data)
{
_scoreController = data.ScoreController;
gcssd = data.GCSSD;
PlayerDataModelSO player = data.PlayerData;
gameplayMods = data.ModifiersData;
modifiers = data.PlayerData.sharedGameplayModifiers;
IDifficultyBeatmap beatmap = data.GCSSD.difficultyBeatmap;
stats = player.currentLocalPlayer.GetPlayerLevelStatsData(
beatmap.level.levelID, beatmap.difficulty, beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
int maxRawScore = ScoreController.MaxRawScoreForNumberOfNotes(beatmap.beatmapData.notesCount);
float modifier = gameplayMods.GetTotalMultiplier(modifiers);
_maxPossibleScore = Mathf.RoundToInt(maxRawScore * modifier);
beginningPB = stats.highScore / (float)_maxPossibleScore;
Vector3 position = CountersController.DeterminePosition(gameObject, settings.Position, settings.Distance);
TextHelper.CreateText(out _PbTrackerText, position);
_PbTrackerText.fontSize = settings.TextSize;
_PbTrackerText.color = Color.white;
_PbTrackerText.alignment = TextAlignmentOptions.Center;
_scoreController.scoreDidChangeEvent += UpdateScore;
SetPersonalBest(beginningPB);
if (settings.UnderScore)
{
StartCoroutine(WaitForScoreCounter());
}
}
public void OnActiveSceneChanged(Scene prevScene, Scene nextScene)
{
customSongColors = UI.BasicUI.ModPrefs.GetBool("SongCore", "customSongColors", true, true);
customSongPlatforms = UI.BasicUI.ModPrefs.GetBool("SongCore", "customSongPlatforms", true, true);
GameObject.Destroy(GameObject.Find("SongCore Color Setter"));
if (nextScene.name == "MenuViewControllers")
{
BS_Utils.Gameplay.Gamemode.Init();
if (PlatformsInstalled)
{
CheckForPreviousPlatform();
}
}
if (nextScene.name == "GameCore")
{
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
Data.ExtraSongData.DifficultyData songData = Collections.RetrieveDifficultyData(data.difficultyBeatmap);
if (songData != null)
{
if (PlatformsInstalled)
{
Logging.logger.Info("Checking Custom Environment");
CheckCustomSongEnvironment(data.difficultyBeatmap);
}
}
else
{
Logging.logger.Info("Null custom song extra data");
}
}
}
internal CustomNoteManager([InjectOptional] Submission submission, NoteAssetLoader noteAssetLoader, IDifficultyBeatmap difficultyBeatmap, GameplayCoreSceneSetupData gameplayCoreSceneSetupData)
{
_submission = submission;
_noteAssetLoader = noteAssetLoader;
_difficultyBeatmap = difficultyBeatmap;
_gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
}
public void Receive(GameplayCoreSceneSetupData gameplayCoreSceneSetupData)
{
this.gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
instance = this;
enabled = false;
}
// Using the magical power of Zenject™, we magically find ourselves with an instance of
// our HUDConfigModel and the CoreGameHUDController.
internal CanvasUtility(HUDConfigModel hudConfig,
MainConfigModel mainConfig,
[Inject(Optional = true)] GameplayCoreSceneSetupData data,
[Inject(Optional = true)] CoreGameHUDController coreGameHUD)
{
this.mainConfig = mainConfig;
if (coreGameHUD != null)
{
hudWidth = Mathf.Abs(coreGameHUD.GetComponentInChildren <ComboUIController>().transform.position.x);
hudDepth = Mathf.Abs(coreGameHUD.GetComponentInChildren <ComboUIController>().transform.position.z);
hudHeight = Mathf.Abs(coreGameHUD.GetComponentInChildren <ComboUIController>().transform.position.y) - 1.5f;
energyCanvas = EnergyPanelGO(ref coreGameHUD).GetComponent <Canvas>();
// Hide Canvas and Multiplier if needed
if (mainConfig.HideCombo)
{
HideBaseGameHUDElement <ComboUIController>(coreGameHUD);
}
if (mainConfig.HideMultiplier)
{
HideBaseGameHUDElement <ScoreMultiplierUIController>(coreGameHUD);
}
}
if (data != null)
{
// HUDType = GetGameplayCoreHUDTypeForEnvironmentSize(data.environmentInfo.environmentType);
}
RefreshAllCanvases(hudConfig, data, coreGameHUD);
}
public void Construct([InjectOptional] IDifficultyBeatmap difficultyBeatmap, AudioTimeSyncController audioTimeSyncController, PauseMenuController pauseMenuController, GameplayCoreSceneSetupData gameplayCoreSceneSetupData, Submission submission)
{
this.difficultyBeatmap = difficultyBeatmap;
this.audioTimeSyncController = audioTimeSyncController;
this.pauseMenuController = pauseMenuController;
this.gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
this.submission = submission;
}
internal MultiplayerPresenceManager([InjectOptional] IGamePause gamePause, PluginConfig pluginConfig, PresenceController presenceController, AudioTimeSyncController audioTimeSyncController, GameplayCoreSceneSetupData gameplayCoreSceneSetupData)
{
this.gamePause = gamePause;
this.pluginConfig = pluginConfig;
this.presenceController = presenceController;
this.audioTimeSyncController = audioTimeSyncController;
this.gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
}
internal CustomNoteManager([InjectOptional] Submission submission, NoteAssetLoader noteAssetLoader, GameplayCoreSceneSetupData gameplayCoreSceneSetupData, PluginConfig pluginConfig, IDifficultyBeatmap level)
{
_submission = submission;
_noteAssetLoader = noteAssetLoader;
_gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
_pluginConfig = pluginConfig;
_level = level;
}
public CountersData()
{
ScoreController = Resources.FindObjectsOfTypeAll <ScoreController>().First();
PlayerController = Resources.FindObjectsOfTypeAll <PlayerController>().First();
AudioTimeSyncController = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().First();
PlayerData = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().First();
ModifiersData = Resources.FindObjectsOfTypeAll <GameplayModifiersModelSO>().First();
GCSSD = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData; //By the time all of these load, so should GCSSD.
}
//ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*
#region // 構築・破棄
public TextFormatter(GameplayCoreSceneSetupData gameplayCoreSceneSetupData)
{
var diff = gameplayCoreSceneSetupData.difficultyBeatmap;
this.SongName = diff.level.songName;
this.SongSubName = diff.level.songSubName;
this.SongAuthorName = diff.level.songAuthorName;
this.Difficulty = diff.difficulty;
}
internal GamePresenceManager([InjectOptional] IGamePause gamePause, [InjectOptional] Submission submission, PluginConfig pluginConfig, PresenceController presenceController, AudioTimeSyncController audioTimeSyncController, GameplayCoreSceneSetupData gameplayCoreSceneSetupData)
{
_gamePause = gamePause;
_submission = submission;
_pluginConfig = pluginConfig;
_presenceController = presenceController;
_audioTimeSyncController = audioTimeSyncController;
_gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
}
public CountersData()
{
BOM = Resources.FindObjectsOfTypeAll <BeatmapObjectManager>().First();
ScoreController = Resources.FindObjectsOfTypeAll <ScoreController>().First();
PlayerController = Resources.FindObjectsOfTypeAll <PlayerController>().First();
AudioTimeSyncController = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().First();
PlayerData = Resources.FindObjectsOfTypeAll <PlayerDataModel>().First();
ModifiersData = Resources.FindObjectsOfTypeAll <GameplayModifiersModelSO>().First();
GCSSD = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData; //By the time all of these load, so should GCSSD.
Is360Or90Level = Resources.FindObjectsOfTypeAll <FlyingGameHUDRotation>().Any(x => x.isActiveAndEnabled);
}
public override void InstallBindings()
{
if (Container.HasBinding <GameplayCoreSceneSetupData>())
{
GameplayCoreSceneSetupData sceneSetupData = Container.Resolve <GameplayCoreSceneSetupData>();
float lastNoteTime = sceneSetupData.difficultyBeatmap.beatmapData.GetLastNoteTime();
Container.Bind <float>().WithId("LastNoteTime").FromInstance(lastNoteTime).AsSingle();
Container.BindInterfacesAndSelfTo <BSEvents>().AsSingle();
}
Container.BindInterfacesAndSelfTo <PlatformSpawnerGame>().AsSingle().WithArguments(Container).NonLazy();
}
public SongData()
{
try
{
BOSC = Resources.FindObjectsOfTypeAll <BeatmapObjectSpawnController>().First();
GCSSD = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData;
modifierData = Resources.FindObjectsOfTypeAll <GameplayModifiersModelSO>().First();
playerData = Resources.FindObjectsOfTypeAll <PlayerDataModel>().First();
scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().First();
} catch (Exception)
{
Logger.log.Error("SongData couldn't be created. Did you start the tutorial ?");
return;
}
if (UserIDFix.UserIDIsReady)
{
playerID = UserIDFix.UserID;
}
else
{
UserIDFix.UserIDReady += SetUserID;
}
songID = GCSSD.difficultyBeatmap.level.levelID.Replace("custom_level_", "").Split('_')[0];
songDifficulty = GCSSD.difficultyBeatmap.difficulty.ToString().ToLower();
gameMode = GCSSD.difficultyBeatmap.level.beatmapLevelData.difficultyBeatmapSets[0].beatmapCharacteristic.serializedName;
songDifficultyRank = GCSSD.difficultyBeatmap.difficultyRank;
songName = GCSSD.difficultyBeatmap.level.songName;
songArtist = GCSSD.difficultyBeatmap.level.songAuthorName;
songMapper = GCSSD.difficultyBeatmap.level.levelAuthorName;
WaitForAudioTimeSyncController();
if (GCSSD.practiceSettings != null)
{
songDataType = SongDataType.practice;
songSpeed = GCSSD.practiceSettings.songSpeedMul;
songStartTime = GCSSD.practiceSettings.startSongTime;
}
else
{
songDataType = SongDataType.replay; // We set it as a replay by default, then set it as a pass if IsNotAReplay() is called
scoreController.scoreDidChangeEvent += IsNotAReplay;
}
dataCollector = new DataCollector();
dataCollector.RegisterCollector(this);
}
public ControllerOffsetPauseViewController([InjectOptional] GameplayCoreSceneSetupData gameplayCoreSceneSetupData, PauseMenuManager pauseMenuManager, SaberManager saberManager, ControllerOffsetPresetsModalController controllerOffsetPresetsModalController, ControllerOffsetSettingsModalController controllerOffsetSettingsModalController) : base(controllerOffsetPresetsModalController, controllerOffsetSettingsModalController)
{
if (gameplayCoreSceneSetupData == null || gameplayCoreSceneSetupData?.practiceSettings == null)
{
practiceMode = false;
return;
}
practiceMode = true;
this.pauseMenuManager = pauseMenuManager;
VRController leftController = saberManager?.leftSaber.GetComponentInParent <VRController>();
VRControllersValueSOOffsets vrControllerTransformOffset = (VRControllersValueSOOffsets)Accessors.VRControllerTransformOffsetAccessor(ref leftController);
positionOffset = Accessors.PositionOffsetAccessor(ref vrControllerTransformOffset);
rotationOffset = Accessors.RotationOffsetAccessor(ref vrControllerTransformOffset);
}
/// <summary>
/// To be invoked every time when starting the GameCore scene.
/// </summary>
public void BeginGameCoreScene()
{
// Get the map metadata
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
this.currentBeatmap = data.difficultyBeatmap;
if (this.IsTransformNecessary() || ConfigOptions.instance.TouchNotes)
{
// Disable scoring due to transforms
Logging.Info("Disabling submission on Game Modifier mode transformation");
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission(Plugin.assemblyName);
SharedCoroutineStarter.instance.StartCoroutine(TransformMap());
}
}
protected void Constractor(
IStatusManager statusManager,
GameStatus gameStatus,
RelativeScoreAndImmediateRankCounter relativeScoreAndImmediateRankCounter,
IAudioTimeSource audioTimeSource,
GameplayCoreSceneSetupData gameplayCoreSceneSetupData,
ISongDataUtil songDataUtil,
IGamePause gamePause)
{
this._statusManager = statusManager;
this._relativeScoreAndImmediateRankCounter = relativeScoreAndImmediateRankCounter;
this._audioTimeSource = audioTimeSource;
this._gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
this._songDataUtil = songDataUtil;
this._gamePause = gamePause;
this._gameStatus = gameStatus;
}
public void RefreshAllCanvases(HUDConfigModel hudConfig, GameplayCoreSceneSetupData data = null, CoreGameHUDController coreGameHUD = null)
{
CanvasIDToCanvas.Clear();
CanvasToSettings.Clear();
CanvasIDToCanvas.Add(-1, CreateCanvasWithConfig(hudConfig.MainCanvasSettings));
CanvasToSettings.Add(CanvasIDToCanvas[-1], hudConfig.MainCanvasSettings);
if (coreGameHUD != null && hudConfig.MainCanvasSettings.ParentedToBaseGameHUD)
{
Transform parent = coreGameHUD.transform;
if (HUDType == GameplayCoreHUDInstaller.HudType.Flying)
{
parent = coreGameHUD.transform.GetChild(0);
}
SoftParent softParent = CanvasIDToCanvas[-1].gameObject.AddComponent <SoftParent>();
softParent.AssignParent(parent);
// Base Game HUD is rotated backwards, so we have to reflect our vector to match.
Vector3 posOofset = Vector3.Reflect(hudConfig.MainCanvasSettings.Position, Vector3.back); // yknow what, f**k it, its posOofset now.
Quaternion rotOofset = Quaternion.Euler(Vector3.Reflect(hudConfig.MainCanvasSettings.Rotation, Vector3.back));
if (HUDType == GameplayCoreHUDInstaller.HudType.Flying) // Special case for Main HUD w/360 environments
{
posOofset = parent.up;
rotOofset = Quaternion.identity;
}
softParent.AssignOffsets(posOofset, rotOofset);
}
for (int i = 0; i < hudConfig.OtherCanvasSettings.Count; i++)
{
HUDCanvas canvasSettings = hudConfig.OtherCanvasSettings[i];
RegisterNewCanvas(canvasSettings, i);
if (coreGameHUD != null && hudConfig.OtherCanvasSettings[i].ParentedToBaseGameHUD)
{
Transform parent = coreGameHUD.transform;
if (HUDType == GameplayCoreHUDInstaller.HudType.Flying)
{
parent = coreGameHUD.transform.GetChild(0);
}
SoftParent softParent = CanvasIDToCanvas[i].gameObject.AddComponent <SoftParent>();
softParent.AssignParent(parent);
}
}
}
public void Construct(PluginConfig config,
Submission submission,
AudioTimeSyncController audioTimeSyncController,
BeatmapLevelsModel beatmapLevelsModel,
GameplayCoreSceneSetupData gameplayCoreSceneSetupData,
GameSongController gameSongController)
{
_config = config;
_submission = submission;
_audioTimeSyncController = audioTimeSyncController;
_beatmapLevelsModel = beatmapLevelsModel;
_gameplayCoreSceneSetupData = gameplayCoreSceneSetupData;
_gameSongController = gameSongController;
_random = new System.Random();
IBeatmapLevelPack beatmapLevelPack = _beatmapLevelsModel.GetLevelPackForLevelId(_gameplayCoreSceneSetupData.difficultyBeatmap.level.levelID);
_previewBeatmapLevels = beatmapLevelPack.beatmapLevelCollection.beatmapLevels;
}
/// <summary>
/// To be invoked every time when starting the GameCore scene.
/// </summary>
public void BeginGameCoreScene()
{
// Get the map metadata
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
this.currentBeatmap = data.difficultyBeatmap;
if (this.IsTransformNecessary() || Configuration.instance.ConfigurationData.TouchNotes)
{
// Disable scoring due to transforms
AlternativePlay.Logger.Info("Disabling score submission on Game Modifier mode transformation");
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission(AlternativePlay.assemblyName);
this.StartCoroutine(this.TransformMap());
}
this.StartCoroutine(this.DisableOtherSaberMesh());
}
