private IEnumerator WaitToCheckDefault()
{
yield return(new WaitUntil(() => Resources.FindObjectsOfTypeAll <Saber>().Any()));
bool hideOneSaber = false;
Saber.SaberType hiddenSaberType = Saber.SaberType.SaberA;
if (BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.characteristicNameLocalizationKey.Contains("ONE_SABER"))
{
hideOneSaber = true;
hiddenSaberType = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.playerSpecificSettings.leftHanded ? Saber.SaberType.SaberB : Saber.SaberType.SaberA;
}
Logger.log.Debug("Default Sabers. Not Replacing");
IEnumerable <Saber> defaultSabers = Resources.FindObjectsOfTypeAll <Saber>();
foreach (Saber defaultSaber in defaultSabers)
{
bool activeState = !hideOneSaber ? true : defaultSaber.saberType != hiddenSaberType;
defaultSaber.gameObject.SetActive(activeState);
if (defaultSaber.saberType == hiddenSaberType)
{
IEnumerable <MeshFilter> meshFilters = defaultSaber.transform.GetComponentsInChildren <MeshFilter>();
foreach (MeshFilter meshFilter in meshFilters)
{
meshFilter.gameObject.SetActive(!sabers);
MeshFilter filter = meshFilter.GetComponentInChildren <MeshFilter>();
filter?.gameObject.SetActive(!sabers);
}
}
}
}
public static bool Prefix(ref Saber.SaberType type, ref Color __result)
{
if (ColourManager.TechnicolourSabers)
{
__result = ColourManager.GetTechnicolour(type == Saber.SaberType.SaberA, Time.time, ChromaConfig.TechnicolourSabersStyle);
return(false);
}
if (type == Saber.SaberType.SaberA)
{
if (ColourManager.A != Color.clear)
{
__result = ColourManager.A;
return(false);
}
}
else
{
if (ColourManager.B != Color.clear)
{
__result = ColourManager.B;
return(false);
}
}
return(true);
}
public override Color ColorForSaberType(Saber.SaberType type) //currently this doesnt work
{
if (type == Saber.SaberType.SaberB)
{
if (--idleB == 0)
{
idleB = skipCount;
if (++counterB == colorsB.Count)
{
counterB = 0;
}
//logger.Log(IPALogger.Level.Info, string.Format("Saber color B index = {0}", counterB));
_saberBColor.SetColor(colorsB[counterB]);
//logger.Log(IPALogger.Level.Info, _saberBColor.ToString());
}
return(_saberBColor);
}
else
{
if (--idleA == 0)
{
idleA = skipCount;
if (++counterA == colorsA.Count)
{
counterA = 0;
}
//logger.Log(IPALogger.Level.Info, string.Format("Saber color A index = {0}", counterA));
_saberAColor.SetColor(colorsA[counterA]);
//logger.Log(IPALogger.Level.Info, _saberAColor.ToString());
}
return(_saberAColor);
}
}
private static SaberType GetOpposite(SaberType saberType)
{
if (saberType == SaberType.SaberA)
{
return(SaberType.SaberB);
}
return(SaberType.SaberA);
}
private void SaberEndCollide(Saber.SaberType saber)
{
try
{
_EventManager.SaberStopColliding.Invoke();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
static bool Prefix(Saber.SaberType saberType)
{
if (PluginConfig.noteCut == false && PluginConfig.enabled)
{
return(false);
}
else
{
return(true);
}
}
private void SaberStartCollide(Saber.SaberType saberType)
{
if (saberType == Saber.SaberType.SaberA)
{
leftEventManager?.SaberStartColliding?.Invoke();
}
else if (saberType == Saber.SaberType.SaberB)
{
rightEventManager?.SaberStartColliding?.Invoke();
}
}
private void SaberEndCollide(Saber.SaberType saber)
{
if (saber == Saber.SaberType.SaberA)
{
_leftEventManager?.SaberStopColliding?.Invoke();
}
else if (saber == Saber.SaberType.SaberB)
{
_rightEventManager?.SaberStopColliding?.Invoke();
}
}
private EventManager GetEventManagerByType(Saber.SaberType saberType)
{
EventManager eventManager = null;
if (saberType == Saber.SaberType.SaberA)
{
eventManager = leftEventManager;
}
else if (saberType == Saber.SaberType.SaberB)
{
eventManager = rightEventManager;
}
return(eventManager);
}
private GameObject GetCustomSaberByType(Saber.SaberType saberType)
{
GameObject saber = null;
if (saberType == Saber.SaberType.SaberA)
{
saber = leftSaber;
}
else if (saberType == Saber.SaberType.SaberB)
{
saber = rightSaber;
}
return(saber);
}
public void onSparkleEffectEnd(Saber.SaberType type)
{
if (haptics != null)
{
// Robust against left being either A or B. Not robust against left and right being the same type.
// This is because the effect manager's exposed events only tell us what type of saber stopped vibrating,
// not whether it was left or right.
if (type == left.saberType)
{
haptics.UpdateStartCount(XRNode.LeftHand,
haptics.getPrivateField <int>("_leftControllerStartRumbleCount") * -1);
}
else
{
haptics.UpdateStartCount(XRNode.RightHand,
haptics.getPrivateField <int>("_rightControllerStartRumbleCount") * -1);
}
}
}
private void ActivateSaber(SaberType saberType)
{
if (saberType == SaberType.SaberA)
{
if (_player.rightSaber.gameObject.activeSelf)
{
_player.leftSaber.gameObject.SetActive(true);
_player.rightSaber.gameObject.SetActive(false);
}
}
else if (saberType == SaberType.SaberB)
{
if (_player.leftSaber.gameObject.activeSelf)
{
_player.rightSaber.gameObject.SetActive(true);
_player.leftSaber.gameObject.SetActive(false);
}
}
}
public virtual void HandleNoteWasCutEvent(BeatmapObjectSpawnController noteSpawnController, NoteController noteController, NoteCutInfo noteCutInfo)
{
try
{
Vector3 notePos = noteController.noteTransform.position;
Vector3 leftPos = _playerController.leftSaber.transform.position;
leftPos += _playerController.leftSaber.transform.forward * 0.5f;
Vector3 rightPos = _playerController.rightSaber.transform.position;
rightPos += _playerController.rightSaber.transform.forward * 0.5f;
float leftDist = Vector3.Distance(leftPos, notePos);
float rightDist = Vector3.Distance(rightPos, notePos);
_mainSettingsModel.controllersRumbleEnabled = true;
Saber.SaberType targetType = (leftDist > rightDist) ? Saber.SaberType.SaberB : Saber.SaberType.SaberA;
_noteCutHapticEffect.RumbleController(targetType);
_mainSettingsModel.controllersRumbleEnabled = false;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
private void TransformToOneColor()
{
const string OneSaberModeName = "OneSaber";
// Check for game mode and early exit on One Saber or NoArrows
GameplayCoreSceneSetupData data = BS_Utils.Plugin.LevelData?.GameplayCoreSceneSetupData;
var beatmap = data.difficultyBeatmap;
string serializedName = beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName;
if (serializedName == OneSaberModeName)
{
// Do not transform for One Saber or legitimate No Arrows mode
Logging.Info($"No need to transform: {beatmap.level.songName} for spear as it is a One Saber map");
return;
}
// Get the in memory beat map
var gameplayCoreSceneSetup = Resources.FindObjectsOfTypeAll <GameplayCoreSceneSetup>().First();
if (gameplayCoreSceneSetup == null)
{
return;
}
var dataModel = gameplayCoreSceneSetup.GetField <BeatmapDataModel>("_beatmapDataModel");
var beatmapData = dataModel.beatmapData;
Logging.Info("Disabling submission on One Color No Arrows transformation");
BS_Utils.Gameplay.ScoreSubmission.DisableSubmission(Plugin.assemblyName);
// Transform the map to One Color and No Arrows
NoteType undesiredNoteType = ConfigOptions.instance.LeftHanded ? NoteType.NoteB : NoteType.NoteA;
foreach (BeatmapLineData line in beatmapData.beatmapLinesData)
{
var objects = line.beatmapObjectsData;
foreach (BeatmapObjectData beatmapObject in objects)
{
if (beatmapObject.beatmapObjectType == BeatmapObjectType.Note)
{
var note = beatmapObject as NoteData;
note.SetNoteToAnyCutDirection();
if (note.noteType == undesiredNoteType)
{
note.SwitchNoteType();
}
}
}
}
// Change the other saber to desired type
Saber.SaberType desiredSaberType = ConfigOptions.instance.LeftHanded ? Saber.SaberType.SaberA : Saber.SaberType.SaberB;
var saberObject = new GameObject("SaberTypeObject").AddComponent <SaberTypeObject>();
saberObject.SetField("_saberType", desiredSaberType);
var player = Resources.FindObjectsOfTypeAll <PlayerController>().FirstOrDefault();
Saber saberToSwap = ConfigOptions.instance.LeftHanded ? player.rightSaber : player.leftSaber;
saberToSwap.SetField("_saberType", saberObject);
}
private IEnumerator WaitForSabers(GameObject saberRoot)
{
yield return(new WaitUntil(() => Resources.FindObjectsOfTypeAll <Saber>().Any()));
var sabers = Resources.FindObjectsOfTypeAll <Saber>();
Saber.SaberType[] typeForHands = new Saber.SaberType[] { Saber.SaberType.SaberB, Saber.SaberType.SaberA };
var playerDataModel = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().FirstOrDefault();
Console.WriteLine("DataModel");
if (playerDataModel && playerDataModel.currentLocalPlayer.playerSpecificSettings.swapColors)
{
typeForHands = typeForHands.Reverse().ToArray();
}
foreach (var saber in sabers)
{
//Disappear default saber
foreach (MeshFilter t in saber.transform.GetComponentsInChildren <MeshFilter>())
{
t.gameObject.SetActive(saberRoot == null);
var filter = t.GetComponentInChildren <MeshFilter>();
if (filter)
{
filter.gameObject.SetActive(saberRoot == null);
}
}
Console.WriteLine("Replacing " + saber.saberType);
CustomTrail[] trails;
if (saber.saberType == typeForHands[0])
{
if (saberRoot == null)
{
}
else
{
_rightSaber.transform.parent = saber.transform;
}
_rightSaber.transform.position = saber.transform.position;
_rightSaber.transform.rotation = saber.transform.rotation;
// Console.WriteLine("PreTrail");
trails = _rightSaber.GetComponents <CustomTrail>();
foreach (CustomTrail trail in trails)
{
trail.Init(saber);
}
}
else if (saber.saberType == typeForHands[1])
{
if (saberRoot == null)
{
}
else
{
_leftSaber.transform.parent = saber.transform;
}
_leftSaber.transform.position = saber.transform.position;
_leftSaber.transform.rotation = saber.transform.rotation;
// Console.WriteLine("PreTrail");
trails = _leftSaber.GetComponents <CustomTrail>();
foreach (CustomTrail trail in trails)
{
trail.Init(saber);
}
}
}
}
private void SaberEndCollide(Saber.SaberType saberType)
{
EventManager eventManager = GetEventManagerByType(saberType);
eventManager?.SaberStopColliding?.Invoke();
}
private void SaberEndCollide(Saber.SaberType saber)
{
_EventManager.SaberStopColliding.Invoke();
}
private IEnumerator WaitForSabers(GameObject saberRoot)
{
yield return(new WaitUntil(() => Resources.FindObjectsOfTypeAll <Saber>().Any()));
var sabers = Resources.FindObjectsOfTypeAll <Saber>();
var typeForHands = new Saber.SaberType[] { Saber.SaberType.SaberB, Saber.SaberType.SaberA };
var playerDataModel = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().FirstOrDefault();
Logger.Log("DataModel", LogLevel.Debug);
foreach (var saber in sabers)
{
//Disappear default saber
foreach (var t in saber.transform.GetComponentsInChildren <MeshFilter>())
{
t.gameObject.SetActive(saberRoot == null);
var filter = t.GetComponentInChildren <MeshFilter>();
if (filter)
{
filter.gameObject.SetActive(saberRoot == null);//.sharedMesh = null;
}
}
Logger.Log($"Replacing {saber.saberType}");
CustomTrail[] trails;
if (saber.saberType == typeForHands[0])
{
if (saberRoot != null)
{
_rightSaber.transform.parent = saber.transform;
}
_rightSaber.transform.position = saber.transform.position;
_rightSaber.transform.rotation = saber.transform.rotation;
//Logger.Log("PreTrail", LogLevel.Debug);
trails = _rightSaber.GetComponents <CustomTrail>();
foreach (var trail in trails)
{
trail.Init(saber);
}
ApplyColorsToSaber(_rightSaber, Plugin.colorManager.ColorForSaberType(Saber.SaberType.SaberB));
}
else if (saber.saberType == typeForHands[1])
{
if (saberRoot != null)
{
_leftSaber.transform.parent = saber.transform;
}
_leftSaber.transform.position = saber.transform.position;
_leftSaber.transform.rotation = saber.transform.rotation;
//Logger.Log("PreTrail", LogLevel.Debug);
trails = _leftSaber.GetComponents <CustomTrail>();
foreach (var trail in trails)
{
trail.Init(saber);
}
ApplyColorsToSaber(_leftSaber, Plugin.colorManager.ColorForSaberType(Saber.SaberType.SaberA));
}
}
}
private void SaberStartCollide(Saber.SaberType saber)
{
_eventManager?.SaberStartColliding?.Invoke();
}
public void addSaber(string name, Vector3 eulerRotation, Vector3 offset, Saber.SaberType type, bool isLeftHand)
{
var oldSaber = isLeftHand ? Plugin.playerController.leftSaber : Plugin.playerController.rightSaber;
/*
* var oldBSMC = (oldSaber
* .GetComponent<SaberModelContainer>()
* .GetField<ISaberModelController>("_saberModelController")
* as BasicSaberModelController);
* oldBSMC.gameObject.name = oldSaber.gameObject.name + " Model";
*/
// disable the template saber so the new one will start out disabled
oldSaber.gameObject.SetActive(false);
var newSaber = GameObject.Instantiate(oldSaber.gameObject).GetComponent <Saber>();
newSaber.name = name;
// unfortunately, getting extra sabers working requires child sacrifice
GameObject.Destroy(newSaber.GetComponentInChildren <SaberWeaponTrail>(true));
// so what's actually going on here:
// the saber's model is a separate GameObject that's a child of the saber, and gets instantiated by Zenject at runtime
// instantiating the saber copies the model, which then SCREAMS AT YOU because its references weren't copied
// so we kill the screaming malformed child, get Zenject to give us a new one, and pretend this never happened
ISMCCContainer.InjectGameObject(newSaber.gameObject);
var smc = newSaber.GetComponent <SaberModelContainer>();
var bsmc = smc.GetField <ISaberModelController>("_saberModelController")
as BasicSaberModelController;
bsmc.gameObject.name = name + " Model";
// it is now safe to turn on your old saber
oldSaber.gameObject.SetActive(true);
// set the saber's type
var sto = newSaber.GetComponent <SaberTypeObject>();
sto.SetField("_saberType", type);
// not sure if these are actually necessary, but just in case
newSaber.SetField("_saberType", sto);
smc.SetField("_saberTypeObject", sto);
// one could imagine a world in which the ColorManager is stored in a separate container from the saber model prefab
// while this is not currently the case... best to be prepared
if (!ISMCCContainer.HasBinding <ColorManager>())
{
colorManagerContainer.InjectGameObject(bsmc.gameObject);
}
var trail = bsmc.GetField <SaberWeaponTrail>("_saberWeaponTrail");
if (!ISMCCContainer.HasBinding <ColorManager>())
{
colorManagerContainer.InjectGameObject(trail.gameObject);
}
// everything's set up; activate the new saber!
newSaber.gameObject.SetActive(true);
// record the info about how to rotate the new saber
sabersByName.Add(name, new SaberInfo
{
eulerRotation = eulerRotation,
offset = offset,
saber = newSaber,
isMainSaber = false,
});
}
private void SpawnController_ScaleRemoveCut(BeatmapObjectSpawnController arg1, INoteController controller, NoteCutInfo arg3)
{
NoteData note = controller.noteData;
Transform noteTransform = controller.noteTransform;
// Log("DESPAWN" + noteTransform.localScale.ToString());
if (noteTransform.localScale.x != 1)
{
noteTransform.localScale = new Vector3(1f, 1f, 1f);
}
// Log("DESPAWN" + noteTransform.localScale.ToString());
// if (modifiedNotes[note.id] != null)
// note = modifiedNotes[note.id];
FloatBehavior behavior = noteTransform.gameObject.GetComponent <FloatBehavior>();
if (behavior != null)
{
noteTransform.localPosition = new Vector3(behavior.originalX, behavior.originalY, noteTransform.localPosition.z);
GameObject.Destroy(behavior);
}
if (GMPUI.oneColor)
{
if (!defaultRumble)
{
return;
}
_noteCutEffectSpawner = UnityEngine.Object.FindObjectOfType <NoteCutEffectSpawner>();
if (_noteCutEffectSpawner != null)
{
_noteCutHapticEffect = ReflectionUtil.GetPrivateField <NoteCutHapticEffect>(_noteCutEffectSpawner, "_noteCutHapticEffect");
}
if (_noteCutHapticEffect != null)
{
_hapticFeedbackController = ReflectionUtil.GetPrivateField <HapticFeedbackController>(_noteCutHapticEffect, "_hapticFeedbackController");
}
if (_hapticFeedbackController != null)
{
_RumbleEnabledOneC = ReflectionUtil.GetPrivateField <BoolSO>(_hapticFeedbackController, "_controllersRumbleEnabled");
}
if (_RumbleEnabledOneC == null)
{
return;
}
Vector3 notePos = controller.noteTransform.position;
Vector3 leftPos = player.leftSaber.transform.position;
leftPos += player.leftSaber.transform.forward * 0.5f;
Vector3 rightPos = player.rightSaber.transform.position;
rightPos += player.rightSaber.transform.forward * 0.5f;
float leftDist = Vector3.Distance(leftPos, notePos);
float rightDist = Vector3.Distance(rightPos, notePos);
// Log(leftDist.ToString() + " " + rightDist.ToString());
_RumbleEnabledOneC.value = true;
Saber.SaberType targetType = (leftDist > rightDist) ? Saber.SaberType.SaberB : Saber.SaberType.SaberA;
if (!(Mathf.Abs(leftDist - rightDist) <= 0.2f))
{
_noteCutHapticEffect.HitNote(targetType);
}
else
{
_noteCutHapticEffect.HitNote(Saber.SaberType.SaberA);
_noteCutHapticEffect.HitNote(Saber.SaberType.SaberB);
}
_RumbleEnabledOneC.value = false;
}
}
private IEnumerator TransformMap()
{
yield return(new WaitForSecondsRealtime(0.1f));
// Set up for One Color
if (ConfigOptions.instance.OneColor && !ConfigOptions.instance.NoArrowsRandom)
{
this.useLeft =
(ConfigOptions.instance.PlayMode == PlayMode.BeatSaber && ConfigOptions.instance.UseLeftSaber) ||
(ConfigOptions.instance.PlayMode == PlayMode.DarthMaul && ConfigOptions.instance.UseLeftController) ||
(ConfigOptions.instance.PlayMode == PlayMode.BeatSpear && ConfigOptions.instance.UseLeftSpear);
this.undesiredNoteType = this.useLeft ? NoteType.NoteB : NoteType.NoteA;
// Change the other saber to desired type
Saber.SaberType desiredSaberType = this.useLeft ? Saber.SaberType.SaberA : Saber.SaberType.SaberB;
var saberObject = new GameObject("SaberTypeObject").AddComponent <SaberTypeObject>();
saberObject.SetField("_saberType", desiredSaberType);
var player = Resources.FindObjectsOfTypeAll <PlayerController>().FirstOrDefault();
Saber saberToSwap = this.useLeft ? player.rightSaber : player.leftSaber;
saberToSwap.SetField("_saberType", saberObject);
if (ConfigOptions.instance.RemoveOtherSaber && ConfigOptions.instance.PlayMode == PlayMode.BeatSaber)
{
// Hide the off color saber
Saber saberToHide = ConfigOptions.instance.UseLeftSaber ? this.playerController.rightSaber : this.playerController.leftSaber;
saberToHide.gameObject.SetActive(false);
}
}
// Get the in memory beat map
BeatmapObjectCallbackController callbackController = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().First();
BeatmapData beatmapData = callbackController.GetField <BeatmapData>("_beatmapData");
if (ConfigOptions.instance.NoArrowsRandom)
{
// Transform the map to No Arrows Random using the ingame algorithm first
Logging.Info($"Transforming NoArrowsRandom for song: {this.currentBeatmap.level.songName}");
var transformedBeatmap = BeatmapDataNoArrowsTransform.CreateTransformedData(beatmapData, true);
callbackController.SetNewBeatmapData(transformedBeatmap);
}
// Transform every note
var allNoteObjects = beatmapData.beatmapLinesData
.SelectMany(line => line.beatmapObjectsData)
.Where(objectData => objectData.beatmapObjectType == BeatmapObjectType.Note)
.ToList();
allNoteObjects.ForEach(beatmapObject =>
{
var note = beatmapObject as NoteData;
// Transform for NoArrows or TouchNotes here but do not if NoArrowsRandom was already applied
if ((ConfigOptions.instance.NoArrows || ConfigOptions.instance.TouchNotes) && !ConfigOptions.instance.NoArrowsRandom)
{
note.SetNoteToAnyCutDirection();
}
// Transform for One Color if this is the other note type
if (ConfigOptions.instance.OneColor && note.noteType == undesiredNoteType)
{
note.SwitchNoteType();
}
});
// Touch Notes speed detection is not handled here but in the HarmonyPatches
}
public void onSparkleEffectStart(Saber.SaberType type)
{
}
