juan/japanese-drum-game
1
0
Fork 0
mirror of https://github.com/jiojciojsioe3/a3cjroijsiojiorj.git synced 2024-11-15 23:41:50 +08:00
Code Issues Packages Projects Releases Wiki Activity
c5f85d0d87
japanese-drum-game/public/src/js/about.js

247 lines
7.7 KiB
JavaScript
Raw Normal View History

Add an issue template translation
2018-10-14 19:02:50 +08:00
class About{
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
constructor(touchEnabled){
this.touchEnabled = touchEnabled
Controller: Separate game and view loops
2019-01-16 20:33:42 +08:00
loader.changePage("about", true)
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
cancelTouch = false
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
this.endButton = this.getElement("view-end-button")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
this.diagTxt = document.getElementById("diag-txt")
this.version = document.getElementById("version-link").href
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
this.tutorialOuter = this.getElement("view-outer")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
if(touchEnabled){
this.tutorialOuter.classList.add("touch-enabled")
}
Custom url for issues link
2019-01-25 12:24:43 +08:00
this.linkIssues = document.getElementById("link-issues")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
this.linkEmail = document.getElementById("link-email")
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
var tutorialTitle = this.getElement("view-title")
Strings: Translate views
2019-01-23 02:47:09 +08:00
tutorialTitle.innerText = strings.aboutSimulator
tutorialTitle.setAttribute("alt", strings.aboutSimulator)
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
var tutorialContent = this.getElement("view-content")
Strings: Translate views
2019-01-23 02:47:09 +08:00
strings.about.bugReporting.forEach(string => {
tutorialContent.appendChild(document.createTextNode(string))
tutorialContent.appendChild(document.createElement("br"))
})
var span = document.createElement("span")
span.classList.add("text-warn")
span.innerText = strings.about.diagnosticWarning
tutorialContent.appendChild(span)
this.endButton.innerText = strings.tutorial.ok
this.endButton.setAttribute("alt", strings.tutorial.ok)
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
this.items = []
Lots of bug fixes - Toggling autoplay checkbox in debug now disallows saving the score - Fix crown of the song that was previously selected rendering above the genre - Outline of empty crowns is slightly darker - Fix rendering when there is a crown on oni and no crown on ura - Fix crowns overlapping the netplay 2P icon - Fix gauge in latency calibration - Fix debug to work on mobile, can be toggled with ctrl+alt+`;` on hacker's keyboard with permanent notification - Fix being unable to scroll the settings list without toggling something - Handle KeyboardInterrupt in server.py - Fix category jumping not working in session mode - Fix mouse cursor being hidden at results screen in session mode - Make "Issues" on the about screen and "An error occurred, please refresh" on loading screens translateable - CanvasCache uses integer increments for comparison instead of Date.now() - For imported songs, exclude song titles from genre comparisons if they appear in the name of the folder - Fix tja files with spaces in the notation - Fix second player's score on the results screen to have upside down appearance - Add fixed chinese strings
2020-03-09 20:36:57 +08:00
this.getLink(this.linkIssues).innerText = strings.about.issues
this.linkIssues.setAttribute("alt", strings.about.issues)
solidify default git repo
2019-02-07 02:49:25 +08:00
var versionUrl = gameConfig._version.url
Custom url for issues link
2019-01-25 12:24:43 +08:00
this.getLink(this.linkIssues).href = versionUrl + "issues"
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
this.items.push(this.linkIssues)
remove hardcoded email address
2019-09-16 00:15:41 +08:00
var contactEmail = gameConfig.email
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
this.hasEmail = typeof contactEmail === "string"
if(this.hasEmail){
remove hardcoded email address
2019-09-16 00:15:41 +08:00
this.linkEmail.setAttribute("alt", contactEmail)
this.getLink(this.linkEmail).href = "mailto:" + contactEmail
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
this.getLink(this.linkEmail).innerText = contactEmail
this.items.push(this.linkEmail)
}else{
this.linkEmail.parentNode.removeChild(this.linkEmail)
remove hardcoded email address
2019-09-16 00:15:41 +08:00
}
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
Custom url for issues link
2019-01-25 12:24:43 +08:00
pageEvents.add(this.linkIssues, ["click", "touchend"], this.linkButton.bind(this))
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
if(this.hasEmail){
pageEvents.add(this.linkEmail, ["click", "touchend"], this.linkButton.bind(this))
}
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
pageEvents.add(this.endButton, ["mousedown", "touchstart"], this.onEnd.bind(this))
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
this.items.push(this.endButton)
this.selected = this.items.length - 1
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
this.keyboard = new Keyboard({
confirm: ["enter", "space", "don_l", "don_r"],
previous: ["left", "up", "ka_l"],
next: ["right", "down", "ka_r"],
back: ["escape"]
}, this.keyPressed.bind(this))
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
this.gamepad = new Gamepad({
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
"confirm": ["b", "ls", "rs"],
"previous": ["u", "l", "lb", "lt", "lsu", "lsl"],
"next": ["d", "r", "rb", "rt", "lsd", "lsr"],
"back": ["start", "a"]
}, this.keyPressed.bind(this))
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
Custom scripting, #song=, translations - A song can be linked directly by adding "#song=<id>" to the url, replace `<id>` with the id in the database, after loading it jumps immediately jumps to the difficulty selection - Added tutorial translations - Fixed song preview not playing - Use text fallback for the logo when there are no vectors - Increased combo cache by 1 pixel - A custom javascript file can be loaded from config.json by defining "custom_js" value - Added lots of events to help writing custom js files: `version-link, title-screen, language-change, song-select, song-select-move, song-select-difficulty, song-select-back, about, about-link, tutorial, import-songs, import-songs-default, session, session-start, session-end, debug, load-song, load-song-player2, load-song-unfocused, load-song-cancel, load-song-error, game-start, key-events, p2-game-end, p2-disconnected, p2-abandoned, pause, unpause, pause-restart, pause-song-select, game-lag, scoresheet, scoresheet-player2` - Event syntax example: ```js addEventListener("game-start", event => { console.log("game-start", event.detail) }) ```
2019-02-14 17:32:45 +08:00
pageEvents.send("about", this.addDiag())
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
getElement(name){
return loader.screen.getElementsByClassName(name)[0]
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
}
keyPressed(pressed, name){
if(!pressed){
return
}
var selected = this.items[this.selected]
if(name === "confirm"){
if(selected === this.endButton){
this.onEnd()
}else{
this.getLink(selected).click()
pageEvents.send("about-link", selected)
assets.sounds["se_don"].play()
}
}else if(name === "previous" || name === "next"){
selected.classList.remove("selected")
this.selected = this.mod(this.items.length, this.selected + (name === "next" ? 1 : -1))
this.items[this.selected].classList.add("selected")
assets.sounds["se_ka"].play()
}else if(name === "back"){
this.onEnd()
}
}
mod(length, index){
return ((index % length) + length) % length
}
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
onEnd(event){
var touched = false
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
if(event){
if(event.type === "touchstart"){
event.preventDefault()
touched = true
}else if(event.which !== 1){
return
}
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
this.clean()
audio overhaul
2019-02-04 17:14:42 +08:00
assets.sounds["se_don"].play()
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
localStorage.setItem("tutorial", "true")
setTimeout(() => {
new SongSelect("about", false, touched)
}, 500)
}
addDiag(){
var diag = []
diag.push("```")
diag.push("Taiko-Web version: " + this.version)
View: Add category info
2018-11-21 17:02:53 +08:00
diag.push("URL: " + location.href)
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
diag.push("User agent: " + navigator.userAgent)
diag.push("Screen size: " + innerWidth + "x" + innerHeight + ", outer: " + outerWidth + "x" + outerHeight + ", ratio: " + (window.devicePixelRatio || 1).toFixed(2))
if(this.touchEnabled){
diag.push("Touch enabled: true")
}
if(!fullScreenSupported){
diag.push("Full screen supported: false")
}
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
diag.push("Blur performance: " + perf.blur + "ms, all images: " + perf.allImg + "ms")
diag.push("Page load: " + (perf.load / 1000).toFixed(1) + "s")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
if("getGamepads" in navigator){
var gamepads = navigator.getGamepads()
for(var i = 0; i < gamepads.length; i++){
if(gamepads[i]){
var gamepadDiag = []
gamepadDiag.push(gamepads[i].id)
gamepadDiag.push("buttons: " + gamepads[i].buttons.length)
gamepadDiag.push("axes: " + gamepads[i].axes.length)
diag.push("Gamepad #" + (i + 1) + ": " + gamepadDiag.join(", "))
}
}
}
Strings: Translate views
2019-01-23 02:47:09 +08:00
var userLangStr = " (none)"
if("languages" in navigator){
var userLang = navigator.languages.slice()
if(userLang[0] !== navigator.language){
userLang.unshift(navigator.language)
}
if(userLang.length !== 0){
userLangStr = " (" + userLang.join(", ") + ")"
}
}
diag.push("Language: " + strings.id + userLangStr)
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
var latency = settings.getItem("latency")
diag.push("Audio Latency: " + (latency.audio > 0 ? "+" : "") + latency.audio.toString() + "ms, Video Latency: " + (latency.video > 0 ? "+" : "") + latency.video.toString() + "ms")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
var errorObj = {}
if(localStorage["lastError"]){
try{
errorObj = JSON.parse(localStorage["lastError"])
}catch(e){}
}
if(errorObj.timestamp && errorObj.stack){
Miscellaneous bug fixes
2018-12-13 17:18:52 +08:00
if(errorObj.timestamp + 1000 * 60 * 60 * 24 > Date.now()){
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
diag.push("Last error: " + errorObj.stack)
diag.push("Error date: " + new Date(errorObj.timestamp).toGMTString())
}else{
localStorage.removeItem("lastError")
}
}
diag.push("```")
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
var diag = diag.join("\n")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
if(navigator.userAgent.indexOf("Android") >= 0){
var iframe = document.createElement("iframe")
this.diagTxt.appendChild(iframe)
var body = iframe.contentWindow.document.body
body.innerText = diag
body.setAttribute("style", `
font-family: monospace;
margin: 2px 0 0 2px;
white-space: pre-wrap;
word-break: break-all;
cursor: text;
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
`)
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
body.setAttribute("onblur", `
getSelection().removeAllRanges()
`)
}else{
this.textarea = document.createElement("textarea")
this.textarea.readOnly = true
this.textarea.value = diag
this.diagTxt.appendChild(this.textarea)
if(!this.touchEnabled){
pageEvents.add(this.textarea, "focus", () => {
this.textarea.select()
})
pageEvents.add(this.textarea, "blur", () => {
getSelection().removeAllRanges()
})
}
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
SoundBuffer: Set song volume - Requires a new column in the database after preview: `volume` REAL - The value is a volume multiplier, if the value is set to null or 1 there will be no change - The volume can be set in debugger - Imported TJA files are now read from disk every time the song is played, freeing some memory and making it easier to create charts - Correctly parse TJA files with alphabet notes, added "A" and "B" notes, which appear as DON (Big) and KA (Big) respectively
2019-03-16 05:34:48 +08:00
var issueBody = strings.about.issueTemplate + "\n\n\n\n" + diag
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
if(this.hasEmail){
this.getLink(this.linkEmail).href += "?body=" + encodeURIComponent(issueBody.replace(/\n/g, "<br>\r\n"))
}
Custom scripting, #song=, translations - A song can be linked directly by adding "#song=<id>" to the url, replace `<id>` with the id in the database, after loading it jumps immediately jumps to the difficulty selection - Added tutorial translations - Fixed song preview not playing - Use text fallback for the logo when there are no vectors - Increased combo cache by 1 pixel - A custom javascript file can be loaded from config.json by defining "custom_js" value - Added lots of events to help writing custom js files: `version-link, title-screen, language-change, song-select, song-select-move, song-select-difficulty, song-select-back, about, about-link, tutorial, import-songs, import-songs-default, session, session-start, session-end, debug, load-song, load-song-player2, load-song-unfocused, load-song-cancel, load-song-error, game-start, key-events, p2-game-end, p2-disconnected, p2-abandoned, pause, unpause, pause-restart, pause-song-select, game-lag, scoresheet, scoresheet-player2` - Event syntax example: ```js addEventListener("game-start", event => { console.log("game-start", event.detail) }) ```
2019-02-14 17:32:45 +08:00
return diag
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
}
getLink(target){
return target.getElementsByTagName("a")[0]
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
linkButton(event){
Change some events, fix p2 sending gameend twice - Fixed gameend being sent twice in p2 - Add `ready`, `loader-error`, and `song-select-random` events - Fixed `session-start` not firing when invited, added event detail - Fixed `language-change` being fired at startup - Fixed `version-link` and `about-link` firing twice - "#song=" will fire `song-select-difficulty` - Removed `key-events` and `scoresheet-player2`, merged with `scoresheet` and made it more detailed
2019-02-15 06:10:34 +08:00
if(event.target === event.currentTarget){
this.getLink(event.currentTarget).click()
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
pageEvents.send("about-link", event.currentTarget)
assets.sounds["se_don"].play()
Change some events, fix p2 sending gameend twice - Fixed gameend being sent twice in p2 - Add `ready`, `loader-error`, and `song-select-random` events - Fixed `session-start` not firing when invited, added event detail - Fixed `language-change` being fired at startup - Fixed `version-link` and `about-link` firing twice - "#song=" will fire `song-select-difficulty` - Removed `key-events` and `scoresheet-player2`, merged with `scoresheet` and made it more detailed
2019-02-15 06:10:34 +08:00
}
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
clean(){
cancelTouch = true
Split language and tutorial, add gamepad settings
2019-04-17 02:06:41 +08:00
this.keyboard.clean()
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
this.gamepad.clean()
Custom url for issues link
2019-01-25 12:24:43 +08:00
pageEvents.remove(this.linkIssues, ["click", "touchend"])
Add global offset Adds new settings for controlling the note offset while playing. It can be either an actual offset (it is called "Audio Latency" in the settings) or just the visual offset ("Video Latency"). With higher audio latency it means you have to press the button sooner than what you hear, similarly with higher video latency it is sooner than what you see. By offsetting these events the game would play better, however, the sound effect of you hitting the drum would still play at the wrong time, the code cannot anticipate you to hit the drum in the future so to work around this issue a new option that disables drum sounds is also included. These settings could be set through trial and error but it would be better to get the correct values through the automated latency calibration, where you can hit the drum as you hear sounds or see a blinking animation. I tried making one by measuring latency from user input, adding all the latency up, and dividing, but that gives unreliable results. I hope someone suggests to me what I should be doing during the calibration to get better results, as I cannot figure what to do on my own.
2019-11-28 14:04:40 +08:00
if(this.hasEmail){
pageEvents.remove(this.linkEmail, ["click", "touchend"])
}
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
pageEvents.remove(this.endButton, ["mousedown", "touchstart"])
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
if(this.textarea){
pageEvents.remove(this.textarea, ["focus", "blur"])
}
Add keyboard and gamepad settings
2019-04-06 03:53:51 +08:00
pageEvents.keyRemove(this, "all")
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
delete this.endButton
delete this.diagTxt
delete this.version
delete this.tutorialOuter
Custom url for issues link
2019-01-25 12:24:43 +08:00
delete this.linkIssues
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
delete this.linkEmail
Add body to button links, add performance to diagnostic
2018-10-14 18:37:27 +08:00
delete this.textarea
SongSelect: Add About screen
2018-10-14 16:04:31 +08:00
}
}
Reference in New Issue Copy Permalink