public override void BeatmapObjectSpawnCallback(BeatmapObjectData beatmapObjectData)
{
if (_disableSpawning)
{
return;
}
float num = _moveDistance / _moveSpeed;
float num2 = _jumpDistance / _noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = transform.forward;
Vector3 a = transform.position;
a += forward * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a2 = a - forward * _moveDistance;
Vector3 a3 = a - forward * (_moveDistance + _jumpDistance);
Vector3 noteOffset = GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType == ObstacleType.Top) ? (_topObstaclePosY + _globalYJumpOffset) : _verticalObstaclePosY);
float height = (obstacleData.obstacleType == ObstacleType.Top) ? this._topObstacleHeight : this._verticalObstacleHeight;
ObstacleController obstacleController = this._obstaclePool.Spawn();
SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(a + noteOffset, Quaternion.identity);
obstacleController.Init(obstacleData, a + noteOffset, a2 + noteOffset, a3 + noteOffset, num, num2, beatmapObjectData.time - _spawnAheadTime, _noteLinesDistance, height);
obstacleController.SetPrivateField("_playerController", owner);
obstacleController.SetPrivateField("_audioTimeSyncController", onlineSyncController);
obstacleController.finishedMovementEvent += ResetControllers;
obstacleController.didDissolveEvent += ResetControllers;
_activeObstacles.Add(obstacleController);
this.GetPrivateField <Action <BeatmapObjectSpawnController, ObstacleController> >("obstacleDiStartMovementEvent")?.Invoke(this, obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = transform.forward;
Vector3 a4 = transform.position;
a4 += forward2 * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a5 = a4 - forward2 * _moveDistance;
Vector3 a6 = a4 - forward2 * (_moveDistance + _jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
a6 += forward2 * _topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController noteController = _bombNotePool.Spawn();
SetNoteControllerEventCallbacks(noteController);
noteController.transform.SetPositionAndRotation(a4 + noteOffset2, Quaternion.identity);
noteController.Init(noteData, a4 + noteOffset2, a5 + noteOffset2, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
var noteJump = noteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController.noteDidFinishJumpEvent += ResetControllers;
noteController.noteWasCutEvent += ResetControllersNoteWasCut;
noteController.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(noteController);
}
else if (noteData.noteType.IsBasicNote())
{
MemoryPool <NoteController> memoryPool = (noteData.noteType == NoteType.NoteA) ? _noteAPool : _noteBPool;
if (_numberOfSpawnedBasicNotes == 0)
{
_firstBasicNoteTime = noteData.time;
}
bool flag = _firstBasicNoteTime == noteData.time;
NoteController noteController2 = memoryPool.Spawn();
SetNoteControllerEventCallbacks(noteController2);
Vector3 noteOffset3 = GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
noteController2.transform.SetPositionAndRotation(a4 + noteOffset3, Quaternion.identity);
GameNoteController gameNoteController = noteController2 as GameNoteController;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity, _disappearingArrows, _ghostNotes && !flag);
}
else
{
noteController2.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
}
var noteJump = noteController2.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController2.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
noteController2.noteDidFinishJumpEvent += ResetControllers;
noteController2.noteWasCutEvent += ResetControllersNoteWasCut;
noteController2.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(noteController2);
_numberOfSpawnedBasicNotes++;
if (_prevSpawnedNormalNoteController != null)
{
float time = _prevSpawnedNormalNoteController.noteData.time;
float time2 = noteController2.noteData.time;
}
_prevSpawnedNormalNoteController = noteController2;
}
}
this.GetPrivateField <Action <BeatmapObjectSpawnController, BeatmapObjectData, float, float> >("beatmapObjectWasSpawnedEvent")?.Invoke(this, beatmapObjectData, num, num2);
}
public void listNote()
{
NoteController noteController = new NoteController();
noteView.ItemsSource = noteController.printNote();
}
static bool Prefix(BeatmapObjectManager __instance, NoteController noteController, NoteCutInfo noteCutInfo)
{
try
{
if (Config.Instance.SpectatorMode && SpectatingController.Instance != null && SpectatingController.active && Client.Instance != null && Client.Instance.connected && SpectatingController.Instance.spectatedPlayer != null && SpectatingController.Instance.spectatedPlayer.playerInfo != null)
{
ulong playerId = SpectatingController.Instance.spectatedPlayer.playerInfo.playerId;
if (SpectatingController.Instance.playerUpdates.ContainsKey(playerId) && SpectatingController.Instance.playerUpdates[playerId].hits.Count > 0)
{
if (SpectatingController.Instance.playerUpdates[playerId].hits.TryGetValue(noteController.noteData.id, out HitData hit))
{
bool allIsOKExpected = hit.noteWasCut && hit.speedOK && hit.saberTypeOK && hit.directionOK && !hit.wasCutTooSoon;
if (hit.noteWasCut)
{
if (noteCutInfo.allIsOK == allIsOKExpected)
{
return(true);
}
else if (!noteCutInfo.allIsOK && allIsOKExpected)
{
#if DEBUG
Plugin.log.Warn("Oopsie, we missed it, let's forget about that");
#endif
__instance.Despawn(noteController);
return(false);
}
else if (noteCutInfo.allIsOK && !allIsOKExpected)
{
#if DEBUG
Plugin.log.Warn("We cut the note, but the player cut it wrong");
#endif
noteCutInfo.SetPrivateProperty("wasCutTooSoon", hit.wasCutTooSoon);
noteCutInfo.SetPrivateProperty("directionOK", hit.directionOK);
noteCutInfo.SetPrivateProperty("saberTypeOK", hit.saberTypeOK);
noteCutInfo.SetPrivateProperty("speedOK", hit.speedOK);
return(true);
}
}
else
{
#if DEBUG
Plugin.log.Warn("We cut the note, but the player missed it");
#endif
__instance.HandleNoteWasMissed(noteController);
return(false);
}
}
}
return(true);
}
else
{
return(true);
}
}catch (Exception e)
{
Plugin.log.Error("Exception in Harmony patch BeatmapObjectSpawnController.NoteWasCut: " + e);
return(true);
}
}
public static void SetActiveColors(this NoteController nc)
{
CNVColorManager.GetCNVColorManager(nc).SetActiveColors();
}
private void Controller_Init(NoteController noteController)
{
SpawnThenParent(bombPool);
}
void RecoveryDetect(float time, HitWindow <GuitarNoteHitKnowledge> hitWindow, int fretInputMask, bool strummed, uint noteStreak)
{
var noteKnowledgeList = hitWindow.noteKnowledgeQueue;
// Search to see if user is hitting a note ahead
List <GuitarNoteHitKnowledge> validatedNotes = new List <GuitarNoteHitKnowledge>();
foreach (GuitarNoteHitKnowledge noteKnowledge in noteKnowledgeList)
{
// Collect all notes the user is possibly hitting
if (
GameplayInputFunctions.ValidateFrets(noteKnowledge.note, fretInputMask, noteStreak) &&
GameplayInputFunctions.ValidateStrum(noteKnowledge.note, canTap, strummed, noteStreak)
)
{
validatedNotes.Add(noteKnowledge);
}
}
if (validatedNotes.Count > 0)
{
// Recovery algorithm
// Select the note closest to the strikeline
float aimYPos = ChartEditor.GetInstance().visibleStrikeline.transform.position.y + 0.25f; // Added offset from the note controller
GuitarNoteHitKnowledge selectedNote = validatedNotes[0];
float dis = -1;
foreach (GuitarNoteHitKnowledge validatedNote in validatedNotes)
{
if (!selectedNote.note.controller)
{
return;
}
NoteController noteController = selectedNote.note.controller;
float distance = Mathf.Abs(aimYPos - noteController.transform.position.y);
if (distance < dis || dis < 0)
{
selectedNote = validatedNote;
dis = distance;
}
}
int index = noteKnowledgeList.IndexOf(selectedNote);
GuitarNoteHitKnowledge note = noteKnowledgeList[index];
// Recovery missed notes
if (index > 0)
{
Debug.Log("Missed notes when performing recovery. Notes skipped = " + index);
}
for (int missedCounter = 0; missedCounter < index; ++missedCounter)
{
MissNote(time, MissSubType.NoteMiss, noteKnowledgeList[missedCounter]);
}
HitNote(time, note);
// We fill out our own knowledge
note.fretValidationTime = time;
note.strumValidationTime = time;
if (strummed)
{
++note.strumCounter;
}
}
else if (strummed)
{
MissNote(time, MissSubType.Overstrum);
Debug.Log("Missed due to strumming when there were no notes to strum during recovery");
}
}
public static void Reset(this NoteController nc)
{
CNVColorManager.GetCNVColorManager(nc)?.Reset();
}
public override void BeatmapObjectSpawnCallback(BeatmapObjectData beatmapObjectData)
{
if (_disableSpawning)
{
return;
}
float num = _moveDistance / _moveSpeed;
float num2 = _jumpDistance / _noteJumpMovementSpeed;
if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Obstacle)
{
ObstacleData obstacleData = (ObstacleData)beatmapObjectData;
Vector3 forward = transform.forward;
Vector3 a = transform.position;
a += forward * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a2 = a - forward * _moveDistance;
Vector3 a3 = a - forward * (_moveDistance + _jumpDistance);
Vector3 noteOffset = GetNoteOffset(beatmapObjectData.lineIndex, NoteLineLayer.Base);
noteOffset.y = ((obstacleData.obstacleType != ObstacleType.Top) ? _verticalObstaclePosY : (_topObstaclePosY + _globalYJumpOffset));
ObstacleController.Pool pool = (obstacleData.obstacleType != ObstacleType.Top) ? _fullHeightObstaclePool : _topObstaclePool;
ObstacleController obstacleController = pool.Spawn();
SetObstacleEventCallbacks(obstacleController);
obstacleController.transform.SetPositionAndRotation(a + noteOffset, Quaternion.identity);
obstacleController.Init(obstacleData, a + noteOffset, a2 + noteOffset, a3 + noteOffset, num, num2, beatmapObjectData.time - _spawnAheadTime, _noteLinesDistance);
obstacleController.SetPrivateField("_playerController", owner);
obstacleController.SetPrivateField("_audioTimeSyncController", onlineSyncController);
obstacleController.finishedMovementEvent += ResetControllers;
obstacleController.didDissolveEvent += ResetControllers;
_activeObstacles.Add(obstacleController);
}
else
{
NoteData noteData = (NoteData)beatmapObjectData;
Vector3 forward2 = transform.forward;
Vector3 a4 = transform.position;
a4 += forward2 * (_moveDistance + _jumpDistance * 0.5f);
Vector3 a5 = a4 - forward2 * _moveDistance;
Vector3 a6 = a4 - forward2 * (_moveDistance + _jumpDistance);
if (noteData.noteLineLayer == NoteLineLayer.Top)
{
a6 += forward2 * _topLinesZPosOffset * 2f;
}
Vector3 noteOffset2 = GetNoteOffset(noteData.lineIndex, noteData.startNoteLineLayer);
float jumpGravity = JumpGravityForLineLayer(noteData.noteLineLayer, noteData.startNoteLineLayer);
if (noteData.noteType == NoteType.Bomb)
{
NoteController bombNoteController = _bombNotePool.Spawn();
SetNoteControllerEventCallbacks(bombNoteController);
bombNoteController.transform.SetPositionAndRotation(a4 + noteOffset2, Quaternion.identity);
bombNoteController.Init(noteData, a4 + noteOffset2, a5 + noteOffset2, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
var noteJump = bombNoteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
bombNoteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
bombNoteController.noteDidFinishJumpEvent += ResetControllers;
bombNoteController.noteWasCutEvent += ResetControllersNoteWasCut;
bombNoteController.noteDidDissolveEvent += ResetControllers;
_activeNotes.Add(bombNoteController);
}
else if (noteData.noteType.IsBasicNote())
{
NoteController.Pool pool2 = (noteData.noteType != NoteType.NoteA) ? _noteBPool : _noteAPool;
NoteController basicNoteController = pool2.Spawn();
SetNoteControllerEventCallbacks(basicNoteController);
Vector3 noteOffset3 = GetNoteOffset(noteData.flipLineIndex, noteData.startNoteLineLayer);
basicNoteController.transform.SetPositionAndRotation(a4 + noteOffset3, Quaternion.identity);
GameNoteController gameNoteController = basicNoteController as GameNoteController;
if (gameNoteController != null)
{
gameNoteController.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity, _disappearingArrows, _ghostNotes);
}
else
{
basicNoteController.Init(noteData, a4 + noteOffset3, a5 + noteOffset3, a6 + noteOffset2, num, num2, noteData.time - _spawnAheadTime, jumpGravity);
}
var noteJump = basicNoteController.GetComponent <NoteJump>();
noteJump.SetPrivateField("_playerController", owner);
noteJump.SetPrivateField("_audioTimeSyncController", onlineSyncController);
basicNoteController.GetComponent <NoteFloorMovement>().SetPrivateField("_audioTimeSyncController", onlineSyncController);
basicNoteController.noteDidFinishJumpEvent += ResetControllers;
basicNoteController.noteWasCutEvent += ResetControllersNoteWasCut;
basicNoteController.noteDidDissolveEvent += ResetControllers;
_prevSpawnedNormalNoteController = basicNoteController;
_activeNotes.Add(basicNoteController);
}
}
}
private void SpawnController_ScaleRemoveCut(BeatmapObjectSpawnController arg1, NoteController controller, NoteCutInfo arg3)
{
NoteData note = controller.noteData;
Transform noteTransform = controller.GetField <Transform>("_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);
}
}
private void NoteWasCut(NoteController noteController, in NoteCutInfo noteCutInfo)
private void ResetControllersNoteWasCut(NoteController controller, NoteCutInfo info)
{
ResetControllers(controller);
}
public virtual void HandleColorNoteVisualsDidInitEvent(ColorNoteVisuals colorNoteVisuals, NoteController noteController)
{
if (!_initialized)
{
_initialized = true;
for (var i = 0; i < _initialSpriteAlphas.Length; i++)
{
_initialSpriteAlphas[i] = SpriteRenderers[i].color.a;
}
}
OnColorNoteVisualsDidInit?.Invoke();
}
void OnNoteCutEvent(NoteController noteController, NoteCutInfo noteCutInfo) => OnNoteCut?.Invoke();
// Do not create a BombCutSoundEffect for fake notes
private static bool Prefix(NoteController noteController)
{
return(FakeNoteHelper.GetFakeNote(noteController));
}
private void BeatmapObjectSpawnController_noteWasCutEvent(BeatmapObjectSpawnController NoteSpawnController, NoteController NoteController, NoteCutInfo NoteCutInfo)
{
if (HapticFeedbackController == null)
{
return;
}
RumblingHands[NoteCutInfo.saberType].Rumble();
}
private void SpawnController_ModifiedJump(BeatmapObjectSpawnController arg1, NoteController controller)
{
if (GMPUI.rainbow)
{
Utilities.Rainbow.RandomizeColors();
invalidForScoring = true;
}
Transform noteTransform = controller.GetField <Transform>("_noteTransform");
// noteTransform.Translate(0f, 4f, 0f);
if (GMPUI.funky)
{
noteTransform.gameObject.AddComponent <FloatBehavior>();
invalidForScoring = true;
}
if (!haveSongNJS)
{
songNJS = spawnController.GetField <float>("_noteJumpMovementSpeed");
haveSongNJS = true;
}
// Transform noteTransform = controller.GetField<Transform>("_noteTransform");
// Log("SPAWN" + noteTransform.localScale.ToString());
if (GMPUI.chatIntegration || GMPUI.randomSize)
{
if (superRandom)
{
noteTransform.localScale *= UnityEngine.Random.Range(Config.randomMin, Config.randomMax);
invalidForScoring = true;
}
else
{
if (!GMPUI.randomSize)
{
noteTransform.localScale *= altereddNoteScale;
invalidForScoring = true;
}
if (GMPUI.randomSize)
{
noteTransform.localScale *= UnityEngine.Random.Range(Config.randomMin, Config.randomMax);
invalidForScoring = true;
}
}
}
// Log("SPAWN" + noteTransform.localScale.ToString());
if (GMPUI.fixedNoteScale != 1f)
{
invalidForScoring = true;
// Transform noteTransform = controller.GetField<Transform>("_noteTransform");
// Log("SPAWN" + noteTransform.localScale.ToString());
noteTransform.localScale *= GMPUI.fixedNoteScale;
// Log("SPAWN" + noteTransform.localScale.ToString());
}
NoteData note = controller.noteData;
}
private static void Prefix(NoteController noteController)
{
NoteColorizer.EnableNoteColorOverride(noteController);
}
private void Start()
{
flashController = GetComponent <FlashController>();
noteController = GetComponent <NoteController>();
}
public void NoteManagement()
{
// User created
var createUserRequest = new UserController.CreateUserRequest();
createUserRequest.Email = Guid.NewGuid().ToString("N") + "@test.com";
createUserRequest.Password = Guid.NewGuid().ToString("N");
UserController.CreateUserResponse response = new UserController().CreateUser(createUserRequest);
Assert.IsTrue(response.Error == "Success");
Assert.IsFalse(string.IsNullOrEmpty(response.Token));
// Get Last Update Time
var lastUpdateQuery = new NoteController.SimpleRequestInput();
lastUpdateQuery.Email = createUserRequest.Email;
lastUpdateQuery.AuthToken = response.Token;
long?lastUpdate = new NoteController().GetLastUpdate(lastUpdateQuery);
Assert.IsNotNull(lastUpdate);
// Get Recent tokens
var recentTokenQuery = new NoteController.SimpleRequestInput();
recentTokenQuery.Email = createUserRequest.Email;
recentTokenQuery.AuthToken = response.Token;
var tokens = new NoteController().QueryRecentTokens(recentTokenQuery);
Assert.IsTrue(tokens.ContainsKey("searchtags"));
Assert.IsTrue(tokens.ContainsKey("createtags"));
Assert.IsTrue(tokens.ContainsKey("locations"));
Assert.IsTrue(tokens["searchtags"].Count() == 3);
Assert.IsTrue(tokens["createtags"].Count() > 0);
Assert.IsTrue(tokens["locations"].Count() == 0);
var createtags1 = tokens["createtags"].Count();
// Invalid token - Query
var queryNotes = new NoteController.QueryNotesAction();
queryNotes.Email = createUserRequest.Email;
queryNotes.AuthToken = "badToken";
queryNotes.QueryContents = "#tutorial";
NoteController.QueryNotesResponse queryResponse = new NoteController().QueryNotes(queryNotes);
Assert.AreEqual("Expired", queryResponse.Status);
// Correct token - Query
queryNotes.AuthToken = response.Token;
queryNotes.QueryContents = "#tutorial";
queryResponse = new NoteController().QueryNotes(queryNotes);
Assert.AreEqual("Success", queryResponse.Status);
Assert.IsTrue(queryResponse.Notes.Count() > 0);
queryNotes.AuthToken = response.Token;
queryNotes.QueryContents = $"{DateTime.UtcNow.AddDays(-1).ToString("yyyy/MM/dd")}-{DateTime.UtcNow.ToString("yyyy/MM/dd")}";
queryResponse = new NoteController().QueryNotes(queryNotes);
Assert.AreEqual("Success", queryResponse.Status);
Assert.IsTrue(queryResponse.Notes.Count() > 0);
// Get Recent tokens
tokens = new NoteController().QueryRecentTokens(recentTokenQuery);
Assert.IsTrue(tokens.ContainsKey("searchtags"));
Assert.IsTrue(tokens.ContainsKey("createtags"));
Assert.IsTrue(tokens.ContainsKey("locations"));
Assert.IsTrue(tokens["searchtags"].Count() == 3);
Assert.IsTrue(tokens["createtags"].Count() > 0);
Assert.IsTrue(tokens["locations"].Count() == 0);
// Invalid token - Create
var createNote = new NoteController.CreateNoteAction();
createNote.Email = createUserRequest.Email;
createNote.AuthToken = "badToken";
createNote.NoteContents = "#test test note";
createNote.City = "Bellevue";
createNote.Latitude = 47.610150F;
createNote.Longitude = -122.201516F;
var createNoteResponse = new NoteController().CreateNote(createNote);
Assert.AreEqual("Expired", createNoteResponse.Status);
// Correct token - Create
createNote.AuthToken = response.Token;
createNoteResponse = new NoteController().CreateNote(createNote);
Assert.AreEqual("Success", createNoteResponse.Status);
// Note creation updates timestamp
var lastUpdate2 = new NoteController().GetLastUpdate(lastUpdateQuery);
Assert.IsNotNull(lastUpdate2 > lastUpdate);
// Get Recent tokens
tokens = new NoteController().QueryRecentTokens(recentTokenQuery);
Assert.IsTrue(tokens.ContainsKey("searchtags"));
Assert.IsTrue(tokens.ContainsKey("createtags"));
Assert.IsTrue(tokens.ContainsKey("locations"));
Assert.AreEqual(tokens["searchtags"].Count(), 4);
Assert.IsTrue(tokens["createtags"].Count() > createtags1);
Assert.IsTrue(tokens["locations"].Count() == 1);
Assert.AreEqual(tokens["locations"].First(), "Bellevue");
// Query new note
queryNotes.QueryContents = "#test";
queryResponse = new NoteController().QueryNotes(queryNotes);
Assert.AreEqual("Success", queryResponse.Status);
Assert.IsTrue(queryResponse.Notes.Count() == 1);
Assert.AreEqual(queryResponse.Notes.First().GetNoteContents(), createNote.NoteContents);
Assert.IsFalse(queryResponse.Notes.First().Completed);
NoteModel queriedNote = queryResponse.Notes.First();
// Note query does not update timestamp
var lastUpdate3 = new NoteController().GetLastUpdate(lastUpdateQuery);
Assert.IsNotNull(lastUpdate3 == lastUpdate2);
// Get Recent tokens
tokens = new NoteController().QueryRecentTokens(recentTokenQuery);
Assert.IsTrue(tokens.ContainsKey("searchtags"));
Assert.IsTrue(tokens.ContainsKey("createtags"));
Assert.IsTrue(tokens.ContainsKey("locations"));
Assert.IsTrue(tokens["searchtags"].Count() == 4);
Assert.IsTrue(tokens["createtags"].Count() > createtags1);
Assert.IsTrue(tokens["locations"].Count() == 1);
// Incorrect id - Update note
var updateNote = new NoteController.UpdateNoteAction();
updateNote.Email = createUserRequest.Email;
updateNote.AuthToken = response.Token;
updateNote.RowKey = "invalidID";
updateNote.Completed = true;
updateNote.NoteContents = "#test updated note";
var updateResponse = new NoteController().UpdateNote(updateNote);
Assert.AreEqual("Invalid", updateResponse.Status);
// Correct id - Update note
updateNote = new NoteController.UpdateNoteAction();
updateNote.Email = createUserRequest.Email;
updateNote.AuthToken = response.Token;
updateNote.RowKey = queriedNote.Id;
updateNote.Completed = true;
updateNote.NoteContents = "#test updated note";
updateResponse = new NoteController().UpdateNote(updateNote);
Assert.AreEqual("Success", updateResponse.Status);
Assert.AreEqual(queriedNote.Id, updateResponse.Note.Id);
Assert.AreEqual(updateNote.NoteContents, updateResponse.Note.GetNoteContents());
Assert.IsTrue(updateResponse.Note.Completed);
Assert.IsTrue(updateResponse.Note.LastUpdatedTime > queriedNote.LastUpdatedTime);
// Update note updates timestamp
var lastUpdate4 = new NoteController().GetLastUpdate(lastUpdateQuery);
Assert.IsNotNull(lastUpdate4 > lastUpdate3);
// Incorrect id - Delete note
var deleteNote = new NoteController.DeleteNoteAction();
deleteNote.Email = createUserRequest.Email;
deleteNote.AuthToken = response.Token;
deleteNote.RowKey = "Invalid";
var deleteResponse = new NoteController().DeleteNote(deleteNote);
Assert.AreEqual("Invalid", deleteResponse);
// Correct id - Delete note
deleteNote = new NoteController.DeleteNoteAction();
deleteNote.Email = createUserRequest.Email;
deleteNote.AuthToken = response.Token;
deleteNote.RowKey = updateResponse.Note.Id;
deleteResponse = new NoteController().DeleteNote(deleteNote);
Assert.AreEqual("Success", deleteResponse);
// Delete note updates timestamp
var lastUpdate5 = new NoteController().GetLastUpdate(lastUpdateQuery);
Assert.IsNotNull(lastUpdate5 > lastUpdate4);
// Get Recent tokens
tokens = new NoteController().QueryRecentTokens(recentTokenQuery);
Assert.IsTrue(tokens.ContainsKey("searchtags"));
Assert.IsTrue(tokens.ContainsKey("createtags"));
Assert.IsTrue(tokens.ContainsKey("locations"));
Assert.IsTrue(tokens["searchtags"].Count() == 4);
Assert.IsTrue(tokens["createtags"].Count() == createtags1);
Assert.IsTrue(tokens["locations"].Count() == 0);
}
private void Start()
{
globalData = GetComponent <GlobalData>();
noteController = GetComponent <NoteController>();
}
public static void SetNoteColors(this NoteController cnv, Color?color0, Color?color1)
{
CNVColorManager.GetCNVColorManager(cnv)?.SetNoteColors(color0, color1);
}
public void HandleNoteControllerNoteWasCut(NoteController noteController, in NoteCutInfo cutInfo)
internal static void ColorizeSaber(NoteController noteController, in NoteCutInfo noteCutInfo)
public NoteControllerTest()
{
context = new TestData().GetNewInMemoryDabaseWithTestData();
controller = new NoteController(context, new NoteService(context));
}
public static void SpawnController_ScaleRemoveCut(NoteController controller, in NoteCutInfo arg3)
private void SliceCallBack(BeatmapObjectSpawnController beatmapObjectSpawnController, NoteController noteController, NoteCutInfo noteCutInfo)
{
if (!noteCutInfo.allIsOK)
{
_leftEventManager.OnComboBreak.Invoke();
_rightEventManager.OnComboBreak.Invoke();
}
else
{
if (noteCutInfo.saberType == Saber.SaberType.SaberA)
{
_leftEventManager.OnSlice.Invoke();
}
else if (noteCutInfo.saberType == Saber.SaberType.SaberB)
{
_rightEventManager.OnSlice.Invoke();
}
}
if (noteController.noteData.id == LastNoteId)
{
_leftEventManager.OnLevelEnded.Invoke();
_rightEventManager.OnLevelEnded.Invoke();
}
}
// Update is called once per frame
protected override void Update()
{
if (editor.currentState != ChartEditor.State.Editor)
{
return;
}
if (movingSongObjects.Count > 0)
{
if (Input.GetMouseButtonUp(0))
{
CompleteMoveAction();
}
else
{
UpdateSnappedPos();
//Debug.Log("Group move: " + editor.services.mouseMonitorSystem.world2DPosition);
if (editor.services.mouseMonitorSystem.world2DPosition != null)
{
Vector2 mousePosition = (Vector2)editor.services.mouseMonitorSystem.world2DPosition;
int chartPosOffset = (int)(objectSnappedChartPos - initObjectSnappedChartPos);
if (anchorArrayPos >= 0)
{
chartPosOffset = (int)(objectSnappedChartPos - originalSongObjects[anchorArrayPos].tick);
}
//Debug.Log(anchorArrayPos);
bool hitStartOfChart = false;
// Guard for chart limit, if the offset was negative, yet the position becomes greater
if (movingSongObjects.Count > 0 && chartPosOffset < 0 && (uint)((int)originalSongObjects[0].tick + chartPosOffset) > originalSongObjects[0].tick)
{
hitStartOfChart = true;
}
// Update the new positions of all the notes that have been moved
for (int i = 0; i < movingSongObjects.Count; ++i)
{
// Alter X position
if ((SongObject.ID)movingSongObjects[i].classID == SongObject.ID.Note)
{
Note note = movingSongObjects[i] as Note;
if (!note.IsOpenNote())
{
float position = NoteController.GetXPos(0, originalSongObjects[i] as Note) + (mousePosition.x - initMousePos.x); // Offset
note.rawNote = PlaceNote.XPosToNoteNumber(position, editor.laneInfo);
}
}
// Alter chart position
if (!hitStartOfChart)
{
movingSongObjects[i].tick = (uint)((int)originalSongObjects[i].tick + chartPosOffset);
}
else
{
movingSongObjects[i].tick = originalSongObjects[i].tick - originalSongObjects[0].tick;
}
if (movingSongObjects[i].controller)
{
movingSongObjects[i].controller.SetDirty();
}
}
}
// Enable objects into the pool
editor.songObjectPoolManager.EnableNotes(notesToEnable);
editor.songObjectPoolManager.EnableSP(starpowerToEnable);
editor.songObjectPoolManager.EnableChartEvents(chartEventsToEnable);
editor.songObjectPoolManager.EnableBPM(bpmsToEnable);
editor.songObjectPoolManager.EnableTS(timeSignaturesToEnable);
editor.songObjectPoolManager.EnableSections(sectionsToEnable);
editor.songObjectPoolManager.EnableSongEvents(eventsToEnable);
}
}
}
private void NoteMissCallBack(BeatmapObjectSpawnController beatmapObjectSpawnController, NoteController noteController)
{
if (noteController.noteData.noteType != NoteType.Bomb)
{
_leftEventManager.OnComboBreak.Invoke();
_rightEventManager.OnComboBreak.Invoke();
}
if (noteController.noteData.id == LastNoteId)
{
_leftEventManager.OnLevelEnded.Invoke();
_rightEventManager.OnLevelEnded.Invoke();
}
}
public void HandleNoteControllerNoteWasCut(NoteController nc, in NoteCutInfo _)
private static bool Prefix(BeatmapObjectManager __instance, NoteController noteController, in NoteCutInfo noteCutInfo)
