Work Completed

• Implemented RotationDetector.
  • Note: it also includes tilt instructions, but I didn't add them into the game yet since they only make sense if the device is in "portrait" orientation. If we want them, I made a separate ticket to add logic to know, depending on the current device orientation, which way is "left" and "forward".
• Created RotateTestActivity to test the RotationDetector.
• Implemented turn left/right and don't turn instructions using the RotationDetector.
• Implemented freeze instruction:
  • Modified RotationDetector & ShakeDetector to also have a "move" output. This is a special instruction that triggers a game over when the current instruction is freeze.
• Added game mode ideas in GameMode.java

Few things:

I put my SwipeListener class within the SwipeActivity class. Not sure if it would be better to have them separate?

I didn't bother with a button to reset it so it'll just count how many correct swipes you get until until you restart it, but I could easily put that in if we wanted.

Since there are only 4 directions, you may get the same one in a row multiple times, but all 4 should work if you test it long enough.

Again I'm not the best developer (I tried my best) so please suggest improvements!!! I'm sure there are ways to make this code more efficient and what not (ie enum)

• Added TypeInstruction, which makes the user type a random 5-letter word, read from a text file
• Added DialInstruction, which makes the user type a random 7-digit phone number (no need to type the hyphen)
• Extra time is added for both instructions, as they take longer than usual, but we may want to adjust this value
• There is currently an issue, as described in Teams, where the keyboard stays up if it is open when you force stop the program from Android Studio

Set up the game loop. With every loop, we get a random instruction from a list of instructions and then add the corresponding UI elements. If the proper input is received, we clear the UI elements, increase score, wait one second, and then loop again. Also made it so the time available to perform the actions scales with score, but we might want to adjust this scale in the future.

Settings Page

• Created the settings page, where you can change volume settings & clear your high scores.
• When you change the volume it plays a sound so you know how loud it is with the new volume.
• The settings are saved into shared preferences using the LocalData class.

How to Play Page

• Created the How to Play page.
• The practice buttons start the practice mode that Carter had created.
• The rotation instructions are now separate practice modes, since that made more sense after designing the UI for it.
• Fixed the swipe instruction's practice mode not correctly looping through the opposite vs normal type of swipe (i.e., previously the opposite swipes were still random in practice mode).

Difficulty Levels

• Changed the time/music scaling to work linearly.
  • After testing with different curves it just felt weird for it to speed up faster and faster or slower and slower as the game progressed. Linear progression felt much nicer.
• Added the function getMinDuration() for each instruction that returns the absolute minimum amount of time that users will get for this instruction.
  • I picked the duration for each instruction such that I had just enough time to complete them consistently but couldn't afford to make any mistakes.
• Added parameters to the difficulty levels that determine how the time scaling works based on the difficulty.
  • extraDuration indicates the amount of extra time that you start with (this is what gets reduced as your score increases). This is added to each instruction's minimum duration.
  • maxLevel indicates at what level do we reach the maximum speed (i.e., at that level the extraDuration is now 0, so you only have the minimum amount of time for each instruction). This relates to how fast the game speeds up.
• The music scales linearly with the maxLevel. It always starts at 1x and goes up to a maximum of 1.5x when the maxLevel is reached.

Other Stuff

• Fixed some issues in the game activity (sometimes the instructions got triggered twice and/or crashed)
  • If you closed the activity using the back button just before the gameLoop gets triggered for the next instruction, the instruction is disabled in onPause(), but gets re-enabled by the gameLoop before it has time to call onDestroy(). This kept some sensors enabled, which caused instructions to trigger twice when starting a new game and crash the app.
• The game mode & difficulty selection is now saved into local storage.
• Changed the sound effects (score, lose, voice lines) to use SoundPool instead of MediaPlayer.

Demo

Demo showing the new settings & how to play pages: https://user-images.githubusercontent.com/43451024/161648566-384347ae-7caa-4b35-b945-fefbf64c812c.mp4

Work Completed

• Created the LocalData class which provides static access to the shared preferences.
• Added methods to get/set the high score.
• Modified GameActivity & GameOverActivity to get/set the high score where needed.

Work Completed

• Added a tutorial gamemode for each Instruction type.
• Tutorial mode is similar to normal play, except actions within the Instruction type are given in a set order, and upon failure, you redo the action instead of getting a gameover.
• The timer bar is still shown, but time to complete the actions remains constant, no matter how many times an action is completed.
• Score and high-score are hidden, but user will briefly get success feedback after completing or failing an action (correct or incorrect).

Note: Since we wanted instructions to repeat on failure, I had to implement things slightly differently than the demo mode. Instead of making a second constructor, I made a second init function, which takes in a boolean success as a parameter, and adjusts the next instruction to be displayed accordingly. This init function was also added to the parent Instruction class, and is only called in GameActivity if the gamemode is a tutorial mode.

Edit (Fred's changes)

• Renamed Tutorial to Practice.
• Changed feedback text to only appear when instruction is failed. The label was changed from "Incorrect" to "Fail".
• Increased time that feedback stays on screen to 1.5 seconds.
• Added exit button in top-left corner.
• Fixed issues with instructions's new init function (voice commands not being set).

Work Completed

Created nice UIs for the main activities: main_menu, game_settings, game, game_over. The UI is mostly the same as the Figma prototypes I had made.

Game Settings Activity

• New activity where you select the game mode and difficulty.
• Show text description based on user's selection.

Game Activity

• Pause functionality during the game (show/hide overlay).
• Replaced CountDownTimer with ObjectAnimator to have a smooth progress bar.

Game Over Activity

• Show score, high score, difficulty, and game mode.

Instructions

• Changed Type & Dial instructions to be aligned to the top of the screen to make space for the keyboard. Also added extra styling to the EditText field to make it nicer.
• Implemented the difficulty levels in InstructionManager. I also tweaked the probabilities a little bit.

Other

• Added logic to prevent starting an activity multiple times if you clicked the button quickly enough. This was added wherever we started an intent based on a button click.

Demo

https://user-images.githubusercontent.com/43451024/159143417-8ca2a6d3-49c1-4f0b-9d00-5a91708cb222.mp4

Work Completed

• Simplified the playing of voice commands.
  • Instead of having a separate VoiceCommandManager, the logic is defined in the abstract Instruction class.
  • We also didn't need a method to set the voice commands since the variable is protected.
• Added logic to automatically get all audio files with a given prefix so we don't need to specify them manually or update anything when we add new sounds.
• The background music looping had a pause when it restarted, so I fixed it by using 2 media players. This functionality is abstracted in the LoopMediaPlayer class.
• Changed the lose sound effect since it didn't match with the game music. I changed it to something more similar (a chiptune kind of sound).
• Fixed various minor warnings.

• Added sound effects for completing an instruction, and for losing.

• Added background music for the main menu, and a different one for the game activity.

• Game background music playback speed scales with the time allowed to complete the current instruction, but it might be good to tweak the scaling later.

• Added voice commands for main instruction type.

• Voice commands are fully abstracted into the Instruction class, and a new VoiceCommandManager class.

• When new Instruction types are added, the abstract setVoiceCommands() method will need to be overridden. In this method, the protected voiceCommands array must be filled with references to the proper sound files in the R.raw directory.

1. Added Flick (users fling in all directions)

2. Added Swipe in opposite direction: This is just implemented by having the displayed text being randomized between two options.

So SwipeInstruction.java has:

 private String[] rightOptions = {"RIGHT", "OPPOSITE OF LEFT"};
 private String[] leftOptions = {"LEFT", "OPPOSITE OF RIGHT"};
 private String[] upOptions = {"UP", "OPPOSITE OF DOWN"};
 private String[] downOptions = {"DOWN", "OPPOSITE OF UP"};

Then for each case, a random number will determine which one of the two text options in the array will be displayed:

public void display() {
        rand2 = new Random();
        index = rand2.nextInt(rightOptions.length - 0) + 0;

        switch(currentAction){
                 case SWIPE_RIGHT:
                    displayTxt = rightOptions[index]; //either "RIGHT" or "OPPOSITE OF LEFT"
                    addTextView(displayTxt, SMALL_TEXT_SIZE);
                    break;
            case SWIPE_LEFT:
                        // and so on ......

Open to suggestions if either of you can think of a better way to do this :)