2014-06-30 04:17:04 +02:00
|
|
|
/*
|
|
|
|
* opsu! - an open-source osu! client
|
2015-01-16 18:05:44 +01:00
|
|
|
* Copyright (C) 2014, 2015 Jeffrey Han
|
2014-06-30 04:17:04 +02:00
|
|
|
*
|
|
|
|
* opsu! is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* opsu! is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with opsu!. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package itdelatrisu.opsu.states;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
import itdelatrisu.opsu.GameData;
|
|
|
|
import itdelatrisu.opsu.GameData.Grade;
|
2015-01-08 05:45:21 +01:00
|
|
|
import itdelatrisu.opsu.GameImage;
|
2015-01-16 08:00:42 +01:00
|
|
|
import itdelatrisu.opsu.GameMod;
|
2014-12-30 06:00:58 +01:00
|
|
|
import itdelatrisu.opsu.MenuButton;
|
2014-06-30 04:17:04 +02:00
|
|
|
import itdelatrisu.opsu.Opsu;
|
2015-01-21 07:38:02 +01:00
|
|
|
import itdelatrisu.opsu.Options;
|
2014-06-30 04:17:04 +02:00
|
|
|
import itdelatrisu.opsu.OsuFile;
|
2015-01-11 20:17:33 +01:00
|
|
|
import itdelatrisu.opsu.OsuGroupList;
|
2014-06-30 04:17:04 +02:00
|
|
|
import itdelatrisu.opsu.OsuGroupNode;
|
|
|
|
import itdelatrisu.opsu.OsuParser;
|
2015-01-21 07:38:02 +01:00
|
|
|
import itdelatrisu.opsu.OszUnpacker;
|
2015-01-29 06:56:30 +01:00
|
|
|
import itdelatrisu.opsu.ScoreDB;
|
2015-01-30 02:36:23 +01:00
|
|
|
import itdelatrisu.opsu.ScoreData;
|
2014-07-19 02:33:41 +02:00
|
|
|
import itdelatrisu.opsu.SongSort;
|
2014-07-02 01:32:03 +02:00
|
|
|
import itdelatrisu.opsu.Utils;
|
2015-01-08 01:29:51 +01:00
|
|
|
import itdelatrisu.opsu.audio.HitSound;
|
|
|
|
import itdelatrisu.opsu.audio.MusicController;
|
|
|
|
import itdelatrisu.opsu.audio.SoundController;
|
|
|
|
import itdelatrisu.opsu.audio.SoundEffect;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-21 07:38:02 +01:00
|
|
|
import java.io.File;
|
2015-01-28 09:47:24 +01:00
|
|
|
import java.util.Map;
|
2015-01-16 21:44:13 +01:00
|
|
|
import java.util.Stack;
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
import org.lwjgl.opengl.Display;
|
2014-07-18 03:16:15 +02:00
|
|
|
import org.newdawn.slick.Animation;
|
2014-06-30 04:17:04 +02:00
|
|
|
import org.newdawn.slick.Color;
|
|
|
|
import org.newdawn.slick.GameContainer;
|
|
|
|
import org.newdawn.slick.Graphics;
|
|
|
|
import org.newdawn.slick.Image;
|
|
|
|
import org.newdawn.slick.Input;
|
|
|
|
import org.newdawn.slick.SlickException;
|
2014-07-18 03:16:15 +02:00
|
|
|
import org.newdawn.slick.SpriteSheet;
|
2014-06-30 04:17:04 +02:00
|
|
|
import org.newdawn.slick.gui.TextField;
|
|
|
|
import org.newdawn.slick.state.BasicGameState;
|
|
|
|
import org.newdawn.slick.state.StateBasedGame;
|
|
|
|
import org.newdawn.slick.state.transition.EmptyTransition;
|
|
|
|
import org.newdawn.slick.state.transition.FadeInTransition;
|
|
|
|
import org.newdawn.slick.state.transition.FadeOutTransition;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* "Song Selection" state.
|
|
|
|
* <ul>
|
|
|
|
* <li>[Song] - start game (move to game state)
|
|
|
|
* <li>[Back] - return to main menu
|
|
|
|
* </ul>
|
|
|
|
*/
|
|
|
|
public class SongMenu extends BasicGameState {
|
2015-01-29 01:23:02 +01:00
|
|
|
/** The max number of song buttons to be shown on each screen. */
|
|
|
|
private static final int MAX_SONG_BUTTONS = 6;
|
|
|
|
|
|
|
|
/** The max number of score buttons to be shown at a time. */
|
|
|
|
public static final int MAX_SCORE_BUTTONS = 7;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Delay time, in milliseconds, between each search. */
|
2014-07-17 18:49:12 +02:00
|
|
|
private static final int SEARCH_DELAY = 500;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Maximum x offset of song buttons for mouse hover, in pixels. */
|
2015-01-08 22:28:49 +01:00
|
|
|
private static final float MAX_HOVER_OFFSET = 30f;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Song node class representing an OsuGroupNode and file index. */
|
2015-01-16 07:40:34 +01:00
|
|
|
private static class SongNode {
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Song node. */
|
2015-01-16 07:40:34 +01:00
|
|
|
private OsuGroupNode node;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** File index. */
|
2015-01-16 07:40:34 +01:00
|
|
|
private int index;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructor.
|
|
|
|
* @param node the OsuGroupNode
|
|
|
|
* @param index the file index
|
|
|
|
*/
|
|
|
|
public SongNode(OsuGroupNode node, int index) {
|
|
|
|
this.node = node;
|
|
|
|
this.index = index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the associated OsuGroupNode.
|
|
|
|
*/
|
|
|
|
public OsuGroupNode getNode() { return node; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the associated file index.
|
|
|
|
*/
|
|
|
|
public int getIndex() { return index; }
|
|
|
|
}
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Current start node (topmost menu entry). */
|
2014-06-30 04:17:04 +02:00
|
|
|
private OsuGroupNode startNode;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Current focused (selected) node. */
|
2014-06-30 04:17:04 +02:00
|
|
|
private OsuGroupNode focusNode;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** The base node of the previous focus node. */
|
2015-01-16 07:40:34 +01:00
|
|
|
private SongNode oldFocusNode = null;
|
2014-07-09 01:03:43 +02:00
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Stack of previous "random" (F2) focus nodes. */
|
2015-01-16 07:40:34 +01:00
|
|
|
private Stack<SongNode> randomStack = new Stack<SongNode>();
|
2014-07-09 01:03:43 +02:00
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Current focus node's song information. */
|
2015-01-08 18:03:39 +01:00
|
|
|
private String[] songInfo;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Button coordinate values. */
|
2014-06-30 04:17:04 +02:00
|
|
|
private float
|
|
|
|
buttonX, buttonY, buttonOffset,
|
|
|
|
buttonWidth, buttonHeight;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Current x offset of song buttons for mouse hover, in pixels. */
|
2015-01-08 22:28:49 +01:00
|
|
|
private float hoverOffset = 0f;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Current index of hovered song button. */
|
2015-01-08 22:28:49 +01:00
|
|
|
private int hoverIndex = -1;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** The options button (to enter the "Game Options" menu). */
|
2014-12-30 06:00:58 +01:00
|
|
|
private MenuButton optionsButton;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** The search textfield. */
|
2014-06-30 04:17:04 +02:00
|
|
|
private TextField search;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Delay timer, in milliseconds, before running another search.
|
|
|
|
* This is overridden by character entry (reset) and 'esc' (immediate search).
|
|
|
|
*/
|
|
|
|
private int searchTimer;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Information text to display based on the search query. */
|
2014-06-30 04:17:04 +02:00
|
|
|
private String searchResultString;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Loader animation. */
|
2014-07-18 03:16:15 +02:00
|
|
|
private Animation loader;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Whether or not to reset game data upon entering the state. */
|
2015-01-16 06:36:05 +01:00
|
|
|
private boolean resetGame = false;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Whether or not to reset music track upon entering the state. */
|
2015-01-16 21:44:13 +01:00
|
|
|
private boolean resetTrack = false;
|
|
|
|
|
2015-01-22 06:44:45 +01:00
|
|
|
/** Beatmap reloading thread. */
|
2015-01-21 07:38:02 +01:00
|
|
|
private Thread reloadThread;
|
|
|
|
|
2015-01-28 09:47:24 +01:00
|
|
|
/** Current map of scores (Version, ScoreData[]). */
|
|
|
|
private Map<String, ScoreData[]> scoreMap;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
/** Scores for the current focus node. */
|
|
|
|
private ScoreData[] focusScores;
|
|
|
|
|
|
|
|
/** Current start score (topmost score entry). */
|
|
|
|
private int startScore = 0;
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// game-related variables
|
|
|
|
private GameContainer container;
|
|
|
|
private StateBasedGame game;
|
|
|
|
private Input input;
|
|
|
|
private int state;
|
|
|
|
|
|
|
|
public SongMenu(int state) {
|
|
|
|
this.state = state;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void init(GameContainer container, StateBasedGame game)
|
|
|
|
throws SlickException {
|
|
|
|
this.container = container;
|
|
|
|
this.game = game;
|
|
|
|
this.input = container.getInput();
|
|
|
|
|
|
|
|
int width = container.getWidth();
|
|
|
|
int height = container.getHeight();
|
|
|
|
|
|
|
|
// song button background & graphics context
|
2015-01-08 05:45:21 +01:00
|
|
|
Image menuBackground = GameImage.MENU_BUTTON_BG.getImage();
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// song button coordinates
|
|
|
|
buttonX = width * 0.6f;
|
|
|
|
buttonY = height * 0.16f;
|
|
|
|
buttonWidth = menuBackground.getWidth();
|
|
|
|
buttonHeight = menuBackground.getHeight();
|
2015-01-29 01:23:02 +01:00
|
|
|
buttonOffset = (height * 0.8f) / MAX_SONG_BUTTONS;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// search
|
|
|
|
searchTimer = 0;
|
|
|
|
searchResultString = "Type to search!";
|
2015-01-08 05:45:21 +01:00
|
|
|
Image searchIcon = GameImage.MENU_SEARCH.getImage();
|
|
|
|
Image tab = GameImage.MENU_TAB.getImage();
|
2014-06-30 04:17:04 +02:00
|
|
|
search = new TextField(
|
2014-07-02 01:32:03 +02:00
|
|
|
container, Utils.FONT_DEFAULT,
|
2014-07-19 02:33:41 +02:00
|
|
|
(int) buttonX + (tab.getWidth() / 2) + searchIcon.getWidth(),
|
|
|
|
(int) ((height * 0.15f) - (tab.getHeight() * 2.5f)),
|
2014-08-24 20:48:27 +02:00
|
|
|
(int) (buttonWidth / 2), Utils.FONT_DEFAULT.getLineHeight()
|
2014-06-30 04:17:04 +02:00
|
|
|
);
|
|
|
|
search.setBackgroundColor(Color.transparent);
|
|
|
|
search.setBorderColor(Color.transparent);
|
|
|
|
search.setTextColor(Color.white);
|
|
|
|
search.setConsumeEvents(false);
|
|
|
|
search.setMaxLength(60);
|
|
|
|
|
|
|
|
// options button
|
2015-01-08 05:45:21 +01:00
|
|
|
Image optionsIcon = GameImage.MENU_OPTIONS.getImage();
|
2014-12-30 06:00:58 +01:00
|
|
|
optionsButton = new MenuButton(optionsIcon, search.getX() - (optionsIcon.getWidth() * 1.5f), search.getY());
|
2014-12-24 05:41:37 +01:00
|
|
|
optionsButton.setHoverScale(1.75f);
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2014-07-18 03:16:15 +02:00
|
|
|
// loader
|
2015-01-08 05:45:21 +01:00
|
|
|
int loaderDim = GameImage.MENU_MUSICNOTE.getImage().getWidth();
|
|
|
|
SpriteSheet spr = new SpriteSheet(GameImage.MENU_LOADER.getImage(), loaderDim, loaderDim);
|
2014-07-18 03:16:15 +02:00
|
|
|
loader = new Animation(spr, 50);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void render(GameContainer container, StateBasedGame game, Graphics g)
|
|
|
|
throws SlickException {
|
|
|
|
g.setBackground(Color.black);
|
|
|
|
|
|
|
|
int width = container.getWidth();
|
|
|
|
int height = container.getHeight();
|
2015-01-11 05:14:22 +01:00
|
|
|
int mouseX = input.getMouseX(), mouseY = input.getMouseY();
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// background
|
|
|
|
if (focusNode != null)
|
|
|
|
focusNode.osuFiles.get(focusNode.osuFileIndex).drawBG(width, height, 1.0f);
|
|
|
|
|
|
|
|
// header setup
|
|
|
|
float lowerBound = height * 0.15f;
|
2014-07-02 01:32:03 +02:00
|
|
|
g.setColor(Utils.COLOR_BLACK_ALPHA);
|
2014-06-30 04:17:04 +02:00
|
|
|
g.fillRect(0, 0, width, lowerBound);
|
2014-07-02 01:32:03 +02:00
|
|
|
g.setColor(Utils.COLOR_BLUE_DIVIDER);
|
2014-06-30 04:17:04 +02:00
|
|
|
g.setLineWidth(2f);
|
|
|
|
g.drawLine(0, lowerBound, width, lowerBound);
|
|
|
|
g.resetLineWidth();
|
|
|
|
|
|
|
|
// header
|
|
|
|
if (focusNode != null) {
|
2015-01-16 20:46:45 +01:00
|
|
|
float marginX = width * 0.005f, marginY = height * 0.005f;
|
|
|
|
|
2015-01-08 05:45:21 +01:00
|
|
|
Image musicNote = GameImage.MENU_MUSICNOTE.getImage();
|
2014-07-18 03:16:15 +02:00
|
|
|
if (MusicController.isTrackLoading())
|
2015-01-16 20:46:45 +01:00
|
|
|
loader.draw(marginX, marginY);
|
2014-07-18 03:16:15 +02:00
|
|
|
else
|
2015-01-16 20:46:45 +01:00
|
|
|
musicNote.draw(marginX, marginY);
|
2014-07-18 03:16:15 +02:00
|
|
|
int iconWidth = musicNote.getWidth();
|
|
|
|
int iconHeight = musicNote.getHeight();
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-08 18:03:39 +01:00
|
|
|
if (songInfo == null)
|
|
|
|
songInfo = focusNode.getInfo();
|
2015-01-16 20:46:45 +01:00
|
|
|
marginX += 5;
|
|
|
|
Utils.FONT_LARGE.drawString(marginX + iconWidth, marginY, songInfo[0], Color.white);
|
|
|
|
Utils.FONT_DEFAULT.drawString(marginX + iconWidth, marginY + Utils.FONT_LARGE.getLineHeight() * 0.75f, songInfo[1], Color.white);
|
|
|
|
float headerY = marginY + iconHeight;
|
|
|
|
Utils.FONT_BOLD.drawString(marginX, headerY, songInfo[2], Color.white);
|
2014-07-08 19:38:16 +02:00
|
|
|
headerY += Utils.FONT_BOLD.getLineHeight() - 6;
|
2015-01-16 20:46:45 +01:00
|
|
|
Utils.FONT_DEFAULT.drawString(marginX, headerY, songInfo[3], Color.white);
|
2014-07-08 19:38:16 +02:00
|
|
|
headerY += Utils.FONT_DEFAULT.getLineHeight() - 4;
|
2015-01-16 20:46:45 +01:00
|
|
|
Utils.FONT_SMALL.drawString(marginX, headerY, songInfo[4], Color.white);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// song buttons
|
|
|
|
OsuGroupNode node = startNode;
|
2015-01-29 01:23:02 +01:00
|
|
|
for (int i = 0; i < MAX_SONG_BUTTONS && node != null; i++, node = node.next) {
|
2015-01-28 09:47:24 +01:00
|
|
|
// draw the node
|
2015-01-08 22:28:49 +01:00
|
|
|
float offset = (i == hoverIndex) ? hoverOffset : 0f;
|
2015-01-29 09:05:09 +01:00
|
|
|
ScoreData[] scores = getScoreDataForNode(node, false);
|
2015-01-28 09:47:24 +01:00
|
|
|
node.draw(
|
|
|
|
buttonX - offset, buttonY + (i*buttonOffset),
|
|
|
|
(scores == null) ? Grade.NULL : scores[0].getGrade(),
|
|
|
|
(node == focusNode)
|
|
|
|
);
|
|
|
|
|
|
|
|
// load glyphs
|
2014-08-25 05:48:52 +02:00
|
|
|
Utils.loadGlyphs(node.osuFiles.get(0));
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
// score buttons
|
|
|
|
if (focusScores != null) {
|
|
|
|
for (int i = 0; i < MAX_SCORE_BUTTONS; i++) {
|
|
|
|
int rank = startScore + i;
|
|
|
|
if (rank >= focusScores.length)
|
|
|
|
break;
|
|
|
|
long prevScore = (rank + 1 < focusScores.length) ?
|
|
|
|
focusScores[rank + 1].score : -1;
|
|
|
|
focusScores[rank].draw(g, i, rank, prevScore, ScoreData.buttonContains(mouseX, mouseY, i));
|
|
|
|
}
|
|
|
|
|
|
|
|
// scroll bar
|
|
|
|
if (focusScores.length > MAX_SCORE_BUTTONS && ScoreData.areaContains(mouseX, mouseY))
|
|
|
|
ScoreData.drawScrollbar(g, startScore, focusScores.length);
|
|
|
|
}
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// options button
|
|
|
|
optionsButton.draw();
|
|
|
|
|
|
|
|
// sorting tabs
|
2015-01-11 04:49:23 +01:00
|
|
|
SongSort currentSort = SongSort.getSort();
|
2015-01-11 05:14:22 +01:00
|
|
|
SongSort hoverSort = null;
|
|
|
|
for (SongSort sort : SongSort.values()) {
|
|
|
|
if (sort.contains(mouseX, mouseY)) {
|
|
|
|
hoverSort = sort;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-01-11 04:49:23 +01:00
|
|
|
for (SongSort sort : SongSort.VALUES_REVERSED) {
|
|
|
|
if (sort != currentSort)
|
2015-01-11 05:14:22 +01:00
|
|
|
sort.draw(false, sort == hoverSort);
|
2015-01-11 04:49:23 +01:00
|
|
|
}
|
2015-01-11 05:14:22 +01:00
|
|
|
currentSort.draw(true, false);
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// search
|
2015-01-08 05:45:21 +01:00
|
|
|
Image searchIcon = GameImage.MENU_SEARCH.getImage();
|
2014-07-02 01:32:03 +02:00
|
|
|
Utils.FONT_BOLD.drawString(
|
|
|
|
search.getX(), search.getY() - Utils.FONT_BOLD.getLineHeight(),
|
2014-06-30 04:17:04 +02:00
|
|
|
searchResultString, Color.white
|
|
|
|
);
|
|
|
|
searchIcon.draw(search.getX() - searchIcon.getWidth(),
|
2014-07-02 01:32:03 +02:00
|
|
|
search.getY() - Utils.FONT_DEFAULT.getLineHeight());
|
2014-06-30 04:17:04 +02:00
|
|
|
g.setColor(Color.white);
|
|
|
|
search.render(container, g);
|
|
|
|
|
|
|
|
// scroll bar
|
|
|
|
if (focusNode != null) {
|
|
|
|
float scrollStartY = height * 0.16f;
|
|
|
|
float scrollEndY = height * 0.82f;
|
2014-07-02 01:32:03 +02:00
|
|
|
g.setColor(Utils.COLOR_BLACK_ALPHA);
|
2014-06-30 04:17:04 +02:00
|
|
|
g.fillRoundRect(width - 10, scrollStartY, 5, scrollEndY, 4);
|
|
|
|
g.setColor(Color.white);
|
2015-01-11 20:17:33 +01:00
|
|
|
g.fillRoundRect(width - 10, scrollStartY + (scrollEndY * startNode.index / OsuGroupList.get().size()), 5, 20, 4);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
2015-01-21 07:38:02 +01:00
|
|
|
// reloading beatmaps
|
|
|
|
if (reloadThread != null) {
|
|
|
|
// darken the screen
|
|
|
|
g.setColor(Utils.COLOR_BLACK_ALPHA);
|
|
|
|
g.fillRect(0, 0, width, height);
|
|
|
|
|
|
|
|
Utils.drawLoadingProgress(g);
|
|
|
|
}
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// back button
|
2015-01-21 07:38:02 +01:00
|
|
|
else
|
|
|
|
Utils.getBackButton().draw();
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-20 20:52:02 +01:00
|
|
|
Utils.drawVolume(g);
|
2014-07-02 01:32:03 +02:00
|
|
|
Utils.drawFPS();
|
|
|
|
Utils.drawCursor();
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void update(GameContainer container, StateBasedGame game, int delta)
|
|
|
|
throws SlickException {
|
2014-07-07 05:13:33 +02:00
|
|
|
Utils.updateCursor(delta);
|
2015-01-20 20:52:02 +01:00
|
|
|
Utils.updateVolumeDisplay(delta);
|
2014-12-24 05:41:37 +01:00
|
|
|
int mouseX = input.getMouseX(), mouseY = input.getMouseY();
|
|
|
|
Utils.getBackButton().hoverUpdate(delta, mouseX, mouseY);
|
|
|
|
optionsButton.hoverUpdate(delta, mouseX, mouseY);
|
2014-07-07 05:13:33 +02:00
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// search
|
2014-07-09 01:03:43 +02:00
|
|
|
search.setFocus(true);
|
2014-06-30 04:17:04 +02:00
|
|
|
searchTimer += delta;
|
2015-01-21 09:25:19 +01:00
|
|
|
if (searchTimer >= SEARCH_DELAY && reloadThread == null) {
|
2014-06-30 04:17:04 +02:00
|
|
|
searchTimer = 0;
|
|
|
|
|
|
|
|
// store the start/focus nodes
|
2015-01-16 07:40:34 +01:00
|
|
|
if (focusNode != null)
|
|
|
|
oldFocusNode = new SongNode(OsuGroupList.get().getBaseNode(focusNode.index), focusNode.osuFileIndex);
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-11 20:17:33 +01:00
|
|
|
if (OsuGroupList.get().search(search.getText())) {
|
2015-01-16 07:40:34 +01:00
|
|
|
// reset song stack
|
|
|
|
randomStack = new Stack<SongNode>();
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// empty search
|
|
|
|
if (search.getText().isEmpty())
|
|
|
|
searchResultString = "Type to search!";
|
|
|
|
|
|
|
|
// search produced new list: re-initialize it
|
|
|
|
startNode = focusNode = null;
|
2015-01-11 20:17:33 +01:00
|
|
|
if (OsuGroupList.get().size() > 0) {
|
|
|
|
OsuGroupList.get().init();
|
2014-06-30 04:17:04 +02:00
|
|
|
if (search.getText().isEmpty()) { // cleared search
|
|
|
|
// use previous start/focus if possible
|
|
|
|
if (oldFocusNode != null)
|
2015-01-16 07:40:34 +01:00
|
|
|
setFocus(oldFocusNode.getNode(), oldFocusNode.getIndex(), true);
|
2014-06-30 04:17:04 +02:00
|
|
|
else
|
2015-01-11 20:17:33 +01:00
|
|
|
setFocus(OsuGroupList.get().getRandomNode(), -1, true);
|
2014-06-30 04:17:04 +02:00
|
|
|
} else {
|
2015-01-11 20:17:33 +01:00
|
|
|
int size = OsuGroupList.get().size();
|
2014-07-17 18:49:12 +02:00
|
|
|
searchResultString = String.format("%d match%s found!",
|
|
|
|
size, (size == 1) ? "" : "es");
|
2015-01-11 20:17:33 +01:00
|
|
|
setFocus(OsuGroupList.get().getRandomNode(), -1, true);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
2014-07-09 01:03:43 +02:00
|
|
|
oldFocusNode = null;
|
2014-06-30 04:17:04 +02:00
|
|
|
} else if (!search.getText().isEmpty())
|
|
|
|
searchResultString = "No matches found. Hit 'esc' to reset.";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// slide buttons
|
|
|
|
int height = container.getHeight();
|
|
|
|
float targetY = height * 0.16f;
|
|
|
|
if (buttonY > targetY) {
|
|
|
|
buttonY -= height * delta / 20000f;
|
|
|
|
if (buttonY < targetY)
|
|
|
|
buttonY = targetY;
|
|
|
|
} else if (buttonY < targetY) {
|
|
|
|
buttonY += height * delta / 20000f;
|
|
|
|
if (buttonY > targetY)
|
|
|
|
buttonY = targetY;
|
|
|
|
}
|
2015-01-08 22:28:49 +01:00
|
|
|
|
|
|
|
// mouse hover
|
|
|
|
OsuGroupNode node = startNode;
|
|
|
|
boolean isHover = false;
|
2015-01-29 01:23:02 +01:00
|
|
|
for (int i = 0; i < MAX_SONG_BUTTONS && node != null; i++, node = node.next) {
|
2015-01-11 20:17:33 +01:00
|
|
|
float cx = (node.index == OsuGroupList.get().getExpandedIndex()) ? buttonX * 0.9f : buttonX;
|
2015-01-08 22:28:49 +01:00
|
|
|
if ((mouseX > cx && mouseX < cx + buttonWidth) &&
|
|
|
|
(mouseY > buttonY + (i * buttonOffset) && mouseY < buttonY + (i * buttonOffset) + buttonHeight)) {
|
|
|
|
if (i == hoverIndex) {
|
|
|
|
if (hoverOffset < MAX_HOVER_OFFSET) {
|
|
|
|
hoverOffset += delta / 3f;
|
|
|
|
if (hoverOffset > MAX_HOVER_OFFSET)
|
|
|
|
hoverOffset = MAX_HOVER_OFFSET;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
hoverIndex = i;
|
|
|
|
hoverOffset = 0f;
|
|
|
|
}
|
|
|
|
isHover = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!isHover) {
|
|
|
|
hoverOffset = 0f;
|
|
|
|
hoverIndex = -1;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getID() { return state; }
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void mousePressed(int button, int x, int y) {
|
2015-01-16 21:44:13 +01:00
|
|
|
// check mouse button
|
2014-06-30 04:17:04 +02:00
|
|
|
if (button != Input.MOUSE_LEFT_BUTTON)
|
|
|
|
return;
|
|
|
|
|
2015-01-21 07:38:02 +01:00
|
|
|
// block input during beatmap reloading
|
|
|
|
if (reloadThread != null)
|
|
|
|
return;
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// back
|
2014-07-02 01:32:03 +02:00
|
|
|
if (Utils.getBackButton().contains(x, y)) {
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUBACK);
|
2014-12-30 06:41:32 +01:00
|
|
|
((MainMenu) game.getState(Opsu.STATE_MAINMENU)).reset();
|
2014-06-30 04:17:04 +02:00
|
|
|
game.enterState(Opsu.STATE_MAINMENU, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// options
|
|
|
|
if (optionsButton.contains(x, y)) {
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUHIT);
|
2015-01-21 07:38:02 +01:00
|
|
|
game.enterState(Opsu.STATE_OPTIONSMENU, new EmptyTransition(), new FadeInTransition(Color.black));
|
2014-06-30 04:17:04 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (focusNode == null)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// sorting buttons
|
2014-07-19 02:33:41 +02:00
|
|
|
for (SongSort sort : SongSort.values()) {
|
|
|
|
if (sort.contains(x, y)) {
|
|
|
|
if (sort != SongSort.getSort()) {
|
|
|
|
SongSort.setSort(sort);
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
2015-01-11 20:17:33 +01:00
|
|
|
OsuGroupNode oldFocusBase = OsuGroupList.get().getBaseNode(focusNode.index);
|
2014-07-03 00:24:19 +02:00
|
|
|
int oldFocusFileIndex = focusNode.osuFileIndex;
|
|
|
|
focusNode = null;
|
2015-01-11 20:17:33 +01:00
|
|
|
OsuGroupList.get().init();
|
2014-07-11 01:13:53 +02:00
|
|
|
setFocus(oldFocusBase, oldFocusFileIndex, true);
|
2014-07-03 00:24:19 +02:00
|
|
|
}
|
|
|
|
return;
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-11 01:13:53 +02:00
|
|
|
// song buttons
|
2015-01-11 20:17:33 +01:00
|
|
|
int expandedIndex = OsuGroupList.get().getExpandedIndex();
|
2014-07-11 01:13:53 +02:00
|
|
|
OsuGroupNode node = startNode;
|
2015-01-29 01:23:02 +01:00
|
|
|
for (int i = 0; i < MAX_SONG_BUTTONS && node != null; i++, node = node.next) {
|
2014-07-11 01:13:53 +02:00
|
|
|
// is button at this index clicked?
|
|
|
|
float cx = (node.index == expandedIndex) ? buttonX * 0.9f : buttonX;
|
|
|
|
if ((x > cx && x < cx + buttonWidth) &&
|
|
|
|
(y > buttonY + (i * buttonOffset) && y < buttonY + (i * buttonOffset) + buttonHeight)) {
|
2015-01-08 22:28:49 +01:00
|
|
|
float oldHoverOffset = hoverOffset;
|
|
|
|
int oldHoverIndex = hoverIndex;
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// clicked node is already expanded
|
|
|
|
if (node.index == expandedIndex) {
|
2014-07-11 01:13:53 +02:00
|
|
|
if (node.osuFileIndex == focusNode.osuFileIndex) {
|
2014-06-30 04:17:04 +02:00
|
|
|
// if already focused, load the beatmap
|
2014-07-03 05:38:30 +02:00
|
|
|
startGame();
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
} else {
|
|
|
|
// focus the node
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
2014-06-30 04:17:04 +02:00
|
|
|
setFocus(node, 0, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-11 01:13:53 +02:00
|
|
|
// clicked node is a new group
|
|
|
|
else {
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
2014-07-11 01:13:53 +02:00
|
|
|
setFocus(node, -1, false);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
2015-01-08 22:28:49 +01:00
|
|
|
|
|
|
|
// restore hover data
|
|
|
|
hoverOffset = oldHoverOffset;
|
|
|
|
hoverIndex = oldHoverIndex;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// score buttons
|
|
|
|
if (focusScores != null && ScoreData.areaContains(x, y)) {
|
|
|
|
for (int i = 0; i < MAX_SCORE_BUTTONS; i++) {
|
|
|
|
int rank = startScore + i;
|
|
|
|
if (rank >= focusScores.length)
|
|
|
|
break;
|
|
|
|
if (ScoreData.buttonContains(x, y, i)) {
|
|
|
|
// view score
|
|
|
|
GameData data = new GameData(focusScores[rank], container.getWidth(), container.getHeight());
|
|
|
|
((GameRanking) game.getState(Opsu.STATE_GAMERANKING)).setGameData(data);
|
|
|
|
game.enterState(Opsu.STATE_GAMERANKING, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
|
|
|
|
return;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void keyPressed(int key, char c) {
|
2015-01-21 07:38:02 +01:00
|
|
|
// block input during beatmap reloading
|
|
|
|
if (reloadThread != null && !(key == Input.KEY_ESCAPE || key == Input.KEY_F12))
|
|
|
|
return;
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
switch (key) {
|
|
|
|
case Input.KEY_ESCAPE:
|
2015-01-21 07:38:02 +01:00
|
|
|
if (reloadThread != null) {
|
|
|
|
// beatmap reloading: stop parsing OsuFiles by sending interrupt to OsuParser
|
|
|
|
if (reloadThread != null)
|
|
|
|
reloadThread.interrupt();
|
|
|
|
} else if (!search.getText().isEmpty()) {
|
|
|
|
// clear search text
|
2014-06-30 04:17:04 +02:00
|
|
|
search.setText("");
|
|
|
|
searchTimer = SEARCH_DELAY;
|
2014-07-01 07:14:03 +02:00
|
|
|
} else {
|
2015-01-21 07:38:02 +01:00
|
|
|
// return to main menu
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUBACK);
|
2014-12-30 06:41:32 +01:00
|
|
|
((MainMenu) game.getState(Opsu.STATE_MAINMENU)).reset();
|
2014-06-30 04:17:04 +02:00
|
|
|
game.enterState(Opsu.STATE_MAINMENU, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
|
2014-07-01 07:14:03 +02:00
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
case Input.KEY_F1:
|
2015-01-21 07:38:02 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUHIT);
|
|
|
|
game.enterState(Opsu.STATE_OPTIONSMENU, new EmptyTransition(), new FadeInTransition(Color.black));
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
case Input.KEY_F2:
|
2015-01-16 07:40:34 +01:00
|
|
|
if (focusNode == null)
|
|
|
|
break;
|
|
|
|
if (input.isKeyDown(Input.KEY_RSHIFT) || input.isKeyDown(Input.KEY_LSHIFT)) {
|
|
|
|
// shift key: previous random track
|
|
|
|
SongNode prev;
|
|
|
|
if (randomStack.isEmpty() || (prev = randomStack.pop()) == null)
|
|
|
|
break;
|
|
|
|
setFocus(prev.getNode(), prev.getIndex(), true);
|
|
|
|
} else {
|
|
|
|
// random track, add previous to stack
|
|
|
|
randomStack.push(new SongNode(OsuGroupList.get().getBaseNode(focusNode.index), focusNode.osuFileIndex));
|
|
|
|
setFocus(OsuGroupList.get().getRandomNode(), -1, true);
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
2015-01-21 07:38:02 +01:00
|
|
|
case Input.KEY_F5:
|
|
|
|
// TODO: osu! has a confirmation menu
|
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
|
|
|
|
|
|
|
// reset state and node references
|
|
|
|
MusicController.reset();
|
|
|
|
startNode = focusNode = null;
|
|
|
|
oldFocusNode = null;
|
|
|
|
randomStack = new Stack<SongNode>();
|
|
|
|
songInfo = null;
|
|
|
|
hoverOffset = 0f;
|
|
|
|
hoverIndex = -1;
|
|
|
|
search.setText("");
|
|
|
|
searchTimer = SEARCH_DELAY;
|
2015-01-21 09:25:19 +01:00
|
|
|
searchResultString = "Type to search!";
|
2015-01-21 07:38:02 +01:00
|
|
|
|
|
|
|
// reload songs in new thread
|
|
|
|
reloadThread = new Thread() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
// invoke unpacker and parser
|
|
|
|
File beatmapDir = Options.getBeatmapDir();
|
|
|
|
OszUnpacker.unpackAllFiles(Options.getOSZDir(), beatmapDir);
|
|
|
|
OsuParser.parseAllFiles(beatmapDir, container.getWidth(), container.getHeight());
|
|
|
|
|
|
|
|
// initialize song list
|
|
|
|
if (OsuGroupList.get().size() > 0) {
|
|
|
|
OsuGroupList.get().init();
|
|
|
|
setFocus(OsuGroupList.get().getRandomNode(), -1, true);
|
|
|
|
} else if (Options.isThemSongEnabled())
|
|
|
|
MusicController.playThemeSong();
|
|
|
|
|
|
|
|
reloadThread = null;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
reloadThread.start();
|
|
|
|
break;
|
2014-06-30 04:17:04 +02:00
|
|
|
case Input.KEY_F12:
|
2014-07-02 01:32:03 +02:00
|
|
|
Utils.takeScreenShot();
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
case Input.KEY_ENTER:
|
2015-01-16 08:00:42 +01:00
|
|
|
if (focusNode == null)
|
|
|
|
break;
|
|
|
|
if (input.isKeyDown(Input.KEY_RCONTROL) || input.isKeyDown(Input.KEY_LCONTROL)) {
|
|
|
|
// turn on "auto" mod
|
|
|
|
if (!GameMod.AUTO.isActive())
|
|
|
|
GameMod.AUTO.toggle(true);
|
|
|
|
}
|
|
|
|
startGame();
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
case Input.KEY_DOWN:
|
|
|
|
changeIndex(1);
|
|
|
|
break;
|
|
|
|
case Input.KEY_UP:
|
|
|
|
changeIndex(-1);
|
|
|
|
break;
|
|
|
|
case Input.KEY_RIGHT:
|
|
|
|
if (focusNode == null)
|
|
|
|
break;
|
|
|
|
OsuGroupNode next = focusNode.next;
|
|
|
|
if (next != null) {
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
2015-01-14 05:00:09 +01:00
|
|
|
OsuGroupNode oldStartNode = startNode;
|
|
|
|
float oldHoverOffset = hoverOffset;
|
|
|
|
int oldHoverIndex = hoverIndex;
|
2014-07-11 01:13:53 +02:00
|
|
|
setFocus(next, 0, false);
|
2015-01-14 05:00:09 +01:00
|
|
|
if (startNode == oldStartNode) {
|
|
|
|
hoverOffset = oldHoverOffset;
|
|
|
|
hoverIndex = oldHoverIndex;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Input.KEY_LEFT:
|
|
|
|
if (focusNode == null)
|
|
|
|
break;
|
|
|
|
OsuGroupNode prev = focusNode.prev;
|
|
|
|
if (prev != null) {
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUCLICK);
|
2015-01-14 05:00:09 +01:00
|
|
|
OsuGroupNode oldStartNode = startNode;
|
|
|
|
float oldHoverOffset = hoverOffset;
|
|
|
|
int oldHoverIndex = hoverIndex;
|
2014-07-11 01:13:53 +02:00
|
|
|
setFocus(prev, (prev.index == focusNode.index) ? 0 : prev.osuFiles.size() - 1, false);
|
2015-01-14 05:00:09 +01:00
|
|
|
if (startNode == oldStartNode) {
|
|
|
|
hoverOffset = oldHoverOffset;
|
|
|
|
hoverIndex = oldHoverIndex;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Input.KEY_NEXT:
|
2015-01-29 01:23:02 +01:00
|
|
|
changeIndex(MAX_SONG_BUTTONS);
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
case Input.KEY_PRIOR:
|
2015-01-29 01:23:02 +01:00
|
|
|
changeIndex(-MAX_SONG_BUTTONS);
|
2014-06-30 04:17:04 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// wait for user to finish typing
|
|
|
|
if (Character.isLetterOrDigit(c) || key == Input.KEY_BACK)
|
|
|
|
searchTimer = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void mouseDragged(int oldx, int oldy, int newx, int newy) {
|
2015-01-21 07:38:02 +01:00
|
|
|
// block input during beatmap reloading
|
|
|
|
if (reloadThread != null)
|
|
|
|
return;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
int diff = newy - oldy;
|
|
|
|
if (diff == 0)
|
|
|
|
return;
|
|
|
|
int shift = (diff < 0) ? 1 : -1;
|
|
|
|
|
|
|
|
// check mouse button (right click scrolls faster on songs)
|
2014-06-30 04:17:04 +02:00
|
|
|
int multiplier;
|
|
|
|
if (input.isMouseButtonDown(Input.MOUSE_RIGHT_BUTTON))
|
|
|
|
multiplier = 4;
|
|
|
|
else if (input.isMouseButtonDown(Input.MOUSE_LEFT_BUTTON))
|
|
|
|
multiplier = 1;
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
// score buttons
|
|
|
|
if (focusScores != null && focusScores.length >= MAX_SCORE_BUTTONS && ScoreData.areaContains(oldx, oldy)) {
|
|
|
|
int newStartScore = startScore + shift;
|
|
|
|
if (newStartScore >= 0 && newStartScore + MAX_SCORE_BUTTONS <= focusScores.length)
|
|
|
|
startScore = newStartScore;
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
2015-01-29 01:23:02 +01:00
|
|
|
|
|
|
|
// song buttons
|
|
|
|
else
|
|
|
|
changeIndex(shift * multiplier);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void mouseWheelMoved(int newValue) {
|
2015-01-21 07:38:02 +01:00
|
|
|
// block input during beatmap reloading
|
|
|
|
if (reloadThread != null)
|
|
|
|
return;
|
|
|
|
|
2015-01-29 01:23:02 +01:00
|
|
|
int shift = (newValue < 0) ? 1 : -1;
|
|
|
|
int mouseX = input.getMouseX(), mouseY = input.getMouseY();
|
|
|
|
|
|
|
|
// score buttons
|
|
|
|
if (focusScores != null && focusScores.length >= MAX_SCORE_BUTTONS && ScoreData.areaContains(mouseX, mouseY)) {
|
|
|
|
int newStartScore = startScore + shift;
|
|
|
|
if (newStartScore >= 0 && newStartScore + MAX_SCORE_BUTTONS <= focusScores.length)
|
|
|
|
startScore = newStartScore;
|
|
|
|
}
|
|
|
|
|
|
|
|
// song buttons
|
|
|
|
else
|
|
|
|
changeIndex(shift);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void enter(GameContainer container, StateBasedGame game)
|
|
|
|
throws SlickException {
|
|
|
|
Display.setTitle(game.getTitle());
|
2014-12-24 05:41:37 +01:00
|
|
|
Utils.getBackButton().setScale(1f);
|
|
|
|
optionsButton.setScale(1f);
|
2015-01-08 22:28:49 +01:00
|
|
|
hoverOffset = 0f;
|
|
|
|
hoverIndex = -1;
|
2015-01-29 01:23:02 +01:00
|
|
|
startScore = 0;
|
2014-12-21 00:17:04 +01:00
|
|
|
|
|
|
|
// stop playing the theme song
|
|
|
|
if (MusicController.isThemePlaying() && focusNode != null)
|
|
|
|
MusicController.play(focusNode.osuFiles.get(focusNode.osuFileIndex), true);
|
2015-01-15 05:10:19 +01:00
|
|
|
|
2015-01-21 01:01:18 +01:00
|
|
|
// reset music track
|
|
|
|
else if (resetTrack) {
|
|
|
|
MusicController.pause();
|
|
|
|
MusicController.playAt(MusicController.getOsuFile().previewTime, true);
|
|
|
|
resetTrack = false;
|
|
|
|
}
|
|
|
|
|
2015-01-15 06:56:30 +01:00
|
|
|
// unpause track
|
|
|
|
else if (MusicController.isPaused())
|
|
|
|
MusicController.resume();
|
|
|
|
|
2015-01-29 02:57:43 +01:00
|
|
|
// undim track
|
|
|
|
if (MusicController.isTrackDimmed())
|
|
|
|
MusicController.toggleTrackDimmed(1f);
|
|
|
|
|
2015-01-16 07:40:34 +01:00
|
|
|
// reset song stack
|
|
|
|
randomStack = new Stack<SongNode>();
|
|
|
|
|
2015-01-16 06:36:05 +01:00
|
|
|
// reset game data
|
|
|
|
if (resetGame) {
|
|
|
|
((Game) game.getState(Opsu.STATE_GAME)).resetGameData();
|
2015-01-28 09:47:24 +01:00
|
|
|
|
2015-01-25 04:23:49 +01:00
|
|
|
// destroy skin images, if any
|
|
|
|
for (GameImage img : GameImage.values()) {
|
|
|
|
if (img.isSkinnable())
|
|
|
|
img.destroySkinImage();
|
|
|
|
}
|
2015-01-28 09:47:24 +01:00
|
|
|
|
|
|
|
// reload scores
|
2015-01-29 01:23:02 +01:00
|
|
|
if (focusNode != null) {
|
2015-01-29 06:56:30 +01:00
|
|
|
scoreMap = ScoreDB.getMapSetScores(focusNode.osuFiles.get(focusNode.osuFileIndex));
|
2015-01-29 09:05:09 +01:00
|
|
|
focusScores = getScoreDataForNode(focusNode, true);
|
2015-01-29 01:23:02 +01:00
|
|
|
}
|
2015-01-28 09:47:24 +01:00
|
|
|
|
2015-01-16 06:36:05 +01:00
|
|
|
resetGame = false;
|
|
|
|
}
|
2014-07-05 20:29:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void leave(GameContainer container, StateBasedGame game)
|
|
|
|
throws SlickException {
|
|
|
|
search.setFocus(false);
|
2014-06-30 04:17:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Shifts the startNode forward (+) or backwards (-) by a given number of nodes.
|
|
|
|
* Initiates sliding "animation" by shifting the button Y position.
|
2015-01-08 22:28:49 +01:00
|
|
|
* @param shift the number of nodes to shift
|
2014-06-30 04:17:04 +02:00
|
|
|
*/
|
|
|
|
private void changeIndex(int shift) {
|
2015-01-08 22:28:49 +01:00
|
|
|
if (shift == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
int n = shift;
|
|
|
|
boolean shifted = false;
|
|
|
|
while (n != 0) {
|
2014-06-30 04:17:04 +02:00
|
|
|
if (startNode == null)
|
|
|
|
break;
|
2015-01-16 21:44:13 +01:00
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
int height = container.getHeight();
|
2015-01-08 22:28:49 +01:00
|
|
|
if (n < 0 && startNode.prev != null) {
|
2014-06-30 04:17:04 +02:00
|
|
|
startNode = startNode.prev;
|
|
|
|
buttonY += buttonOffset / 4;
|
|
|
|
if (buttonY > height * 0.18f)
|
|
|
|
buttonY = height * 0.18f;
|
2015-01-08 22:28:49 +01:00
|
|
|
n++;
|
|
|
|
shifted = true;
|
|
|
|
} else if (n > 0 && startNode.next != null &&
|
2015-01-29 01:23:02 +01:00
|
|
|
OsuGroupList.get().getNode(startNode, MAX_SONG_BUTTONS) != null) {
|
2014-06-30 04:17:04 +02:00
|
|
|
startNode = startNode.next;
|
|
|
|
buttonY -= buttonOffset / 4;
|
|
|
|
if (buttonY < height * 0.14f)
|
|
|
|
buttonY = height * 0.14f;
|
2015-01-08 22:28:49 +01:00
|
|
|
n--;
|
|
|
|
shifted = true;
|
2014-06-30 04:17:04 +02:00
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
2015-01-08 22:28:49 +01:00
|
|
|
if (shifted) {
|
|
|
|
hoverOffset = 0f;
|
|
|
|
hoverIndex = -1;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets a new focus node.
|
|
|
|
* @param node the base node; it will be expanded if it isn't already
|
|
|
|
* @param pos the OsuFile element to focus; if out of bounds, it will be randomly chosen
|
2014-07-11 01:13:53 +02:00
|
|
|
* @param flag if true, startNode will be set to the first node in the group
|
2014-06-30 04:17:04 +02:00
|
|
|
* @return the old focus node
|
|
|
|
*/
|
|
|
|
public OsuGroupNode setFocus(OsuGroupNode node, int pos, boolean flag) {
|
|
|
|
if (node == null)
|
|
|
|
return null;
|
2014-07-11 01:13:53 +02:00
|
|
|
|
2015-01-08 22:28:49 +01:00
|
|
|
hoverOffset = 0f;
|
|
|
|
hoverIndex = -1;
|
2015-01-08 18:03:39 +01:00
|
|
|
songInfo = null;
|
2014-06-30 04:17:04 +02:00
|
|
|
OsuGroupNode oldFocus = focusNode;
|
|
|
|
|
|
|
|
// expand node before focusing it
|
2015-01-11 20:17:33 +01:00
|
|
|
int expandedIndex = OsuGroupList.get().getExpandedIndex();
|
2014-07-11 01:13:53 +02:00
|
|
|
if (node.index != expandedIndex) {
|
2015-01-11 20:17:33 +01:00
|
|
|
node = OsuGroupList.get().expand(node.index);
|
2014-07-11 01:13:53 +02:00
|
|
|
|
|
|
|
// if start node was previously expanded, move it
|
|
|
|
if (startNode != null && startNode.index == expandedIndex)
|
|
|
|
startNode = node;
|
|
|
|
}
|
2014-06-30 04:17:04 +02:00
|
|
|
|
|
|
|
// check pos bounds
|
|
|
|
int length = node.osuFiles.size();
|
2014-07-11 01:13:53 +02:00
|
|
|
if (pos < 0 || pos > length - 1) // set a random pos
|
|
|
|
pos = (int) (Math.random() * length);
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2014-07-11 01:13:53 +02:00
|
|
|
// change the focus node
|
2014-07-11 04:01:39 +02:00
|
|
|
if (flag || (startNode.index == 0 && startNode.osuFileIndex == -1 && startNode.prev == null))
|
2014-06-30 04:17:04 +02:00
|
|
|
startNode = node;
|
2015-01-11 20:17:33 +01:00
|
|
|
focusNode = OsuGroupList.get().getNode(node, pos);
|
2014-08-25 05:48:52 +02:00
|
|
|
OsuFile osu = focusNode.osuFiles.get(focusNode.osuFileIndex);
|
|
|
|
MusicController.play(osu, true);
|
|
|
|
Utils.loadGlyphs(osu);
|
2014-06-30 04:17:04 +02:00
|
|
|
|
2015-01-28 09:47:24 +01:00
|
|
|
// load scores
|
2015-01-29 06:56:30 +01:00
|
|
|
scoreMap = ScoreDB.getMapSetScores(osu);
|
2015-01-29 09:05:09 +01:00
|
|
|
focusScores = getScoreDataForNode(focusNode, true);
|
2015-01-29 01:23:02 +01:00
|
|
|
startScore = 0;
|
2015-01-28 09:47:24 +01:00
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
// check startNode bounds
|
2015-01-29 01:23:02 +01:00
|
|
|
while (startNode.index >= OsuGroupList.get().size() + length - MAX_SONG_BUTTONS && startNode.prev != null)
|
2014-07-11 01:13:53 +02:00
|
|
|
startNode = startNode.prev;
|
|
|
|
|
|
|
|
// make sure focusNode is on the screen (TODO: cleanup...)
|
2015-01-29 01:23:02 +01:00
|
|
|
int val = focusNode.index + focusNode.osuFileIndex - (startNode.index + MAX_SONG_BUTTONS) + 1;
|
2014-07-11 01:13:53 +02:00
|
|
|
if (val > 0) // below screen
|
|
|
|
changeIndex(val);
|
|
|
|
else { // above screen
|
|
|
|
if (focusNode.index == startNode.index) {
|
|
|
|
val = focusNode.index + focusNode.osuFileIndex - (startNode.index + startNode.osuFileIndex);
|
|
|
|
if (val < 0)
|
|
|
|
changeIndex(val);
|
|
|
|
} else if (startNode.index > focusNode.index) {
|
|
|
|
val = focusNode.index - focusNode.osuFiles.size() + focusNode.osuFileIndex - startNode.index + 1;
|
|
|
|
if (val < 0)
|
|
|
|
changeIndex(val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if start node is expanded and on group node, move it
|
|
|
|
if (startNode.index == focusNode.index && startNode.osuFileIndex == -1)
|
2014-06-30 04:17:04 +02:00
|
|
|
changeIndex(1);
|
|
|
|
|
|
|
|
return oldFocus;
|
|
|
|
}
|
|
|
|
|
2015-01-16 06:36:05 +01:00
|
|
|
/**
|
|
|
|
* Triggers a reset of game data upon entering this state.
|
|
|
|
*/
|
|
|
|
public void resetGameDataOnLoad() { resetGame = true; }
|
|
|
|
|
2015-01-16 21:44:13 +01:00
|
|
|
/**
|
|
|
|
* Triggers a reset of the music track upon entering this state.
|
|
|
|
*/
|
|
|
|
public void resetTrackOnLoad() { resetTrack = true; }
|
|
|
|
|
2015-01-28 09:47:24 +01:00
|
|
|
/**
|
|
|
|
* Returns all the score data for an OsuGroupNode from scoreMap.
|
|
|
|
* If no score data is available for the node, return null.
|
|
|
|
* @param node the OsuGroupNode
|
2015-01-29 09:05:09 +01:00
|
|
|
* @param setTimeSince whether or not to set the "time since" field for the scores
|
2015-01-28 09:47:24 +01:00
|
|
|
* @return the ScoreData array
|
|
|
|
*/
|
2015-01-29 09:05:09 +01:00
|
|
|
private ScoreData[] getScoreDataForNode(OsuGroupNode node, boolean setTimeSince) {
|
2015-01-29 01:23:02 +01:00
|
|
|
if (scoreMap == null || scoreMap.isEmpty() || node.osuFileIndex == -1) // node not expanded
|
2015-01-28 09:47:24 +01:00
|
|
|
return null;
|
|
|
|
|
|
|
|
OsuFile osu = node.osuFiles.get(node.osuFileIndex);
|
|
|
|
ScoreData[] scores = scoreMap.get(osu.version);
|
|
|
|
if (scores == null || scores.length < 1) // no scores
|
|
|
|
return null;
|
|
|
|
|
|
|
|
ScoreData s = scores[0];
|
|
|
|
if (osu.beatmapID == s.MID && osu.beatmapSetID == s.MSID &&
|
|
|
|
osu.title.equals(s.title) && osu.artist.equals(s.artist) &&
|
2015-01-29 09:05:09 +01:00
|
|
|
osu.creator.equals(s.creator)) {
|
|
|
|
if (setTimeSince) {
|
|
|
|
for (int i = 0; i < scores.length; i++)
|
|
|
|
scores[i].getTimeSince();
|
|
|
|
}
|
2015-01-28 09:47:24 +01:00
|
|
|
return scores;
|
2015-01-29 09:05:09 +01:00
|
|
|
} else
|
2015-01-28 09:47:24 +01:00
|
|
|
return null; // incorrect map
|
|
|
|
}
|
|
|
|
|
2014-06-30 04:17:04 +02:00
|
|
|
/**
|
|
|
|
* Starts the game.
|
|
|
|
*/
|
2014-07-03 05:38:30 +02:00
|
|
|
private void startGame() {
|
2014-07-15 06:20:36 +02:00
|
|
|
if (MusicController.isTrackLoading())
|
2014-06-30 04:17:04 +02:00
|
|
|
return;
|
|
|
|
|
2015-01-08 01:29:51 +01:00
|
|
|
SoundController.playSound(SoundEffect.MENUHIT);
|
2014-07-03 05:38:30 +02:00
|
|
|
OsuFile osu = MusicController.getOsuFile();
|
2014-06-30 04:17:04 +02:00
|
|
|
Display.setTitle(String.format("%s - %s", game.getTitle(), osu.toString()));
|
|
|
|
OsuParser.parseHitObjects(osu);
|
2015-01-08 01:29:51 +01:00
|
|
|
HitSound.setSampleSet(osu.sampleSet);
|
2015-01-15 06:56:30 +01:00
|
|
|
((Game) game.getState(Opsu.STATE_GAME)).setRestart(Game.Restart.NEW);
|
2014-06-30 04:17:04 +02:00
|
|
|
game.enterState(Opsu.STATE_GAME, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
|
|
|
|
}
|
|
|
|
}
|