466 lines
16 KiB
CoffeeScript
466 lines
16 KiB
CoffeeScript
http = require 'http'
|
|
Primus = require 'primus'
|
|
Emitter = require('primus-emitter')
|
|
express = require 'express'
|
|
path = require 'path'
|
|
{_} = require 'underscore'
|
|
|
|
{BattleServer} = require './server'
|
|
commands = require './commands'
|
|
auth = require('./auth')
|
|
generations = require './generations'
|
|
{Room} = require('./rooms')
|
|
errors = require '../shared/errors'
|
|
assets = require('../assets')
|
|
database = require('./database')
|
|
redis = require('./redis')
|
|
ratings = require('./ratings')
|
|
config = require('./config')
|
|
alts = require('./alts')
|
|
replays = require('./replays')
|
|
modify = require('./modify')
|
|
|
|
MAX_MESSAGE_LENGTH = 250
|
|
MAX_RANK_DISPLAYED = 100
|
|
|
|
# A MD5 hash of all the JavaScript files used by the client. This is passed to
|
|
# each new connection via the .jade template, and when the client connects. If
|
|
# the two versions differ, the server had restarted at some point and now is
|
|
# serving new client files.
|
|
CLIENT_VERSION = assets.getVersion()
|
|
|
|
@createServer = (port) ->
|
|
app = express()
|
|
httpServer = http.createServer(app)
|
|
primus = new Primus(httpServer, transformer: 'sockjs')
|
|
primus.use('emitter', Emitter)
|
|
primus.save(path.join(__dirname, "../client/vendor/js/primus.js"))
|
|
server = new BattleServer()
|
|
|
|
# Configuration
|
|
app.set("views", "client/templates")
|
|
app.set('view engine', 'jade')
|
|
app.use(express.logger()) if config.IS_LOCAL
|
|
app.use(express.compress()) # gzip
|
|
app.use(express.cookieParser())
|
|
app.use(auth.middleware())
|
|
app.use(express.methodOverride())
|
|
app.use(app.router)
|
|
app.use(express.static(path.join(__dirname, "../public"))) if config.IS_LOCAL
|
|
|
|
# Helpers
|
|
app.locals.asset_path = assets.getAbsolute
|
|
|
|
# Routing
|
|
renderHomepage = (req, res) ->
|
|
res.render('index.jade', user: req.user, CLIENT_VERSION: CLIENT_VERSION)
|
|
|
|
app.get("/", renderHomepage)
|
|
app.get("/battles/:id", renderHomepage)
|
|
app.get("/replays/:id", replays.routes.show)
|
|
app.delete("/replays/:id", replays.routes.destroy)
|
|
app.get("/replays", replays.routes.index)
|
|
|
|
app.get '/leaderboard', (req, res) ->
|
|
page = req.param('page')
|
|
perPage = req.param('per_page')
|
|
ratings.listRatings page, perPage, (err, results) ->
|
|
if err
|
|
res.json(500, err.message)
|
|
else
|
|
res.render('leaderboard.jade', players: results)
|
|
|
|
app.get '/leaderboard/json', (req, res) ->
|
|
page = req.param('page')
|
|
perPage = req.param('per_page')
|
|
ratings.listRatings page, perPage, (err, results) ->
|
|
if err
|
|
res.json(500, err.message)
|
|
else
|
|
res.json(players: results)
|
|
|
|
app.get '/pokeuse/json', (req, res) ->
|
|
user= req.user
|
|
res.json(400) if user.name != "Deukhoofd"
|
|
page = req.param('page')
|
|
perPage = req.param('per_page')
|
|
q = new database.Teams()
|
|
q = q.query('orderBy', 'created_at')
|
|
.fetch()
|
|
.then (teams) ->
|
|
teams = teams.toJSON()
|
|
pkmn = getpokeusedata(teams)
|
|
res.json(teams: pkmn)
|
|
|
|
getpokeusedata = (json) ->
|
|
occurences = []
|
|
for team in json
|
|
for pokemon in team.pokemon
|
|
specie = pokemon.species
|
|
if specie != null
|
|
inarr = _.where(occurences, {name: specie})
|
|
if inarr.length == 0
|
|
newobj = {name: specie, occurence: 1}
|
|
occurences.push(newobj)
|
|
else
|
|
inarr[0].occurence = inarr[0].occurence + 1
|
|
occurences = _.sortBy(occurences, "occurence").reverse()
|
|
totalpokemon = 0
|
|
for pkmn in occurences
|
|
totalpokemon += pkmn.occurence
|
|
for pkmn in occurences
|
|
pkmn.percentage = (pkmn.occurence/totalpokemon) * 100
|
|
return occurences
|
|
|
|
app.get '/pokeuse', (req, res) ->
|
|
|
|
|
|
modifyUsers = ["Deukhoofd", "Simply"]
|
|
app.get '/modify', (req, res) ->
|
|
if req.user.name not in modifyUsers
|
|
res.json(400)
|
|
else
|
|
res.render('modify.jade')
|
|
|
|
app.get '/modify/formes', (req, res) ->
|
|
if req.user.name not in modifyUsers
|
|
res.json(400)
|
|
else
|
|
FormeData = require("./in/data/data_formes.json")
|
|
res.render('modify/formes.jade', data: FormeData)
|
|
|
|
|
|
lobby = new Room("Lobby")
|
|
server.rooms.push(lobby)
|
|
|
|
# Start responding to websocket clients
|
|
primus.on 'connection', (spark) ->
|
|
spark.send('version', CLIENT_VERSION)
|
|
|
|
spark.on 'login', (id, token) ->
|
|
return unless _.isFinite(id)
|
|
return unless _.isString(token)
|
|
requ = spark.request
|
|
auth.matchToken requ, id, token, (err, json) ->
|
|
if err
|
|
return spark.send('errorMessage', errors.INVALID_SESSION)
|
|
|
|
auth.getBanTTL json.name, (err, ttl) ->
|
|
if err
|
|
return spark.send('errorMessage', errors.INVALID_SESSION)
|
|
else if ttl != -2 # -2 means the ban does not exist
|
|
auth.getBanReason json.name, (err, reason) ->
|
|
spark.send('errorMessage', errors.BANNED, reason, Number(ttl))
|
|
spark.end()
|
|
return
|
|
else
|
|
user = server.findOrCreateUser(json, spark)
|
|
if !user.name || !user.id
|
|
console.error("MISSING INFORMATION: #{json}")
|
|
spark.end()
|
|
return
|
|
attachEvents(user, spark)
|
|
server.join(spark)
|
|
spark.loggedIn = true
|
|
spark.send('loginSuccess')
|
|
lobby.add(spark)
|
|
|
|
# After stuff
|
|
alts.listUserAlts user.name, (err, alts) ->
|
|
spark.send('altList', alts)
|
|
|
|
primus.on 'error', (err) ->
|
|
console.error(err.message, err.stack)
|
|
|
|
primus.on 'disconnection', (spark) ->
|
|
return unless spark.loggedIn
|
|
server.leave(spark)
|
|
spark.emit("cancelFindBattle") unless spark.user.hasSparks()
|
|
|
|
attachEvents = (user, spark) ->
|
|
spark.on 'sendChat', (roomId, message) ->
|
|
return unless _.isString(message)
|
|
message = message.trim().replace(/[\u0300-\u036F\u20D0-\u20FF\uFE20-\uFE2F]/g, '')
|
|
return unless 0 < message.length < MAX_MESSAGE_LENGTH
|
|
return unless room = server.getRoom(roomId)
|
|
server.limit user, 'chat', max: 5, duration: 3000, (err, limit) ->
|
|
if err || limit.remaining == 0
|
|
server.runIfUnmuted user, roomId, ->
|
|
server.mute(user.name, '[AUTOMATED] Chat rate-limit.', 10 * 60)
|
|
room = server.getRoom(roomId)
|
|
room.announce('warning', "#{user.name} was automatically muted for 10 minutes.")
|
|
else if message[0] == '/' && message[1] == '/'
|
|
message = message[1...]
|
|
server.userMessage(user, room, message)
|
|
else if message[0] == '/'
|
|
command = message.replace(/\s+.*$/, '')
|
|
args = message.substr(command.length).replace(/^\s+/, '')
|
|
command = command.substr(1)
|
|
args = args.split(',')
|
|
commands.executeCommand(server, user, room, command, args...)
|
|
else
|
|
server.userMessage(user, room, message)
|
|
if limit.remaining == 1
|
|
user.announce(room.name, 'warning', 'You are chatting too fast. Please slow down.')
|
|
|
|
spark.on 'leaveChatroom', (roomId) ->
|
|
return unless _.isString(roomId)
|
|
server.getRoom(roomId)?.remove(spark)
|
|
|
|
#########
|
|
# TEAMS #
|
|
#########
|
|
|
|
# Takes a temporary id and team JSON. Saves to server, and returns the real
|
|
# unique id that was persisted onto the DB.
|
|
spark.on 'saveTeam', (team, callback) ->
|
|
return unless _.isObject(team)
|
|
return unless _.isFunction(callback)
|
|
attributes = _.pick(team, 'id', 'name', 'generation')
|
|
attributes['trainer_id'] = user.id
|
|
attributes['contents'] = JSON.stringify(team.pokemon)
|
|
new database.Team(attributes)
|
|
.save().then (team) ->
|
|
callback(team.id)
|
|
|
|
spark.on 'requestTeams', ->
|
|
q = new database.Teams()
|
|
if user.authority != auth.levels.OWNER
|
|
q = q.query('where', trainer_id: user.id)
|
|
q = q.query('orderBy', 'created_at')
|
|
.fetch()
|
|
.then (teams) ->
|
|
spark.send('receiveTeams', teams.toJSON())
|
|
|
|
spark.on 'destroyTeam', (teamId) ->
|
|
return unless _.isFinite(teamId)
|
|
attributes = {
|
|
id: teamId
|
|
}
|
|
attributes['trainer_id'] = user.id unless config.IS_LOCAL
|
|
|
|
database.Team.query().where(attributes).delete()
|
|
.then ->
|
|
# Do nothing, just execute the promise. We assume it was deleted.
|
|
return
|
|
.catch (err) ->
|
|
console.error(err)
|
|
|
|
####################
|
|
# PRIVATE MESSAGES #
|
|
####################
|
|
|
|
spark.on 'privateMessage', (toUser, message) ->
|
|
return unless _.isString(toUser)
|
|
return unless _.isString(message)
|
|
message = message.trim().replace(/[\u0300-\u036F\u20D0-\u20FF\uFE20-\uFE2F]/g, '')
|
|
return unless 0 < message.length < MAX_MESSAGE_LENGTH
|
|
if server.users.contains(toUser)
|
|
recipient = server.users.get(toUser)
|
|
recipient.send('privateMessage', user.name, user.name, message)
|
|
user.send('privateMessage', toUser, user.name, message)
|
|
else
|
|
user.error(errors.PRIVATE_MESSAGE, toUser, "This user is offline.")
|
|
|
|
##############
|
|
# CHALLENGES #
|
|
##############
|
|
|
|
spark.on 'challenge', (challengeeId, generation, team, conditions, altName) ->
|
|
return unless _.isString(challengeeId)
|
|
return unless _.isString(generation)
|
|
return unless _.isObject(team)
|
|
return unless _.isArray(conditions)
|
|
return unless !altName || _.isString(altName)
|
|
alts.isAltOwnedBy user.name, altName, (err, valid) ->
|
|
return user.error(errors.INVALID_ALT_NAME, "You do not own this alt") unless valid
|
|
server.registerChallenge(user, challengeeId, generation, team, conditions, altName)
|
|
|
|
spark.on 'cancelChallenge', (challengeeId) ->
|
|
return unless _.isString(challengeeId)
|
|
server.cancelChallenge(user, challengeeId)
|
|
|
|
spark.on 'acceptChallenge', (challengerId, team, altName) ->
|
|
return unless _.isString(challengerId)
|
|
return unless _.isObject(team)
|
|
return unless !altName || _.isString(altName)
|
|
alts.isAltOwnedBy user.name, altName, (err, valid) ->
|
|
return user.error(errors.INVALID_ALT_NAME, "You do not own this alt") unless valid
|
|
server.acceptChallenge(user, challengerId, team, altName)
|
|
|
|
spark.on 'rejectChallenge', (challengerId) ->
|
|
return unless _.isString(challengerId)
|
|
server.rejectChallenge(user, challengerId)
|
|
|
|
########
|
|
# ALTS #
|
|
########
|
|
|
|
spark.on 'createAlt', (altName) ->
|
|
altName = String(altName).trim()
|
|
if !alts.isAltNameValid(altName)
|
|
return user.error(errors.INVALID_ALT_NAME, "Invalid Alt Name")
|
|
alts.createAlt user.name, altName, (err, success) ->
|
|
return user.error(errors.INVALID_ALT_NAME, err.message) if err
|
|
user.send('altCreated', altName) if success
|
|
|
|
###########
|
|
# REPLAYS #
|
|
###########
|
|
|
|
spark.on 'saveReplay', (battleId, callback) ->
|
|
battle = server.findBattle(battleId)
|
|
return callback?("The battle could not be found.") unless battle
|
|
return callback?("The battle is not yet done.") unless battle.isOver()
|
|
replays.create(user, battle.battle) # unwrap the facade
|
|
.then((replayId) -> callback?(null, replayId))
|
|
.catch replays.TooManyBattlesSaved, (err) ->
|
|
callback?(err.message)
|
|
.catch (err) ->
|
|
callback?('Something went wrong saving the replay.')
|
|
console.error(err.message)
|
|
console.error(err.stack)
|
|
|
|
###########
|
|
# BATTLES #
|
|
###########
|
|
|
|
spark.on 'getBattleList', (callback) ->
|
|
return unless _.isFunction(callback)
|
|
# TODO: Make this more efficient
|
|
# TODO: Order by age
|
|
# NOTE: Cache this? Even something like a 5 second expiration
|
|
# may improve server performance greatly
|
|
currentTime = Date.now()
|
|
battleMetadata = ([
|
|
controller.battle.id,
|
|
controller.battle.playerNames[0],
|
|
controller.battle.playerNames[1],
|
|
currentTime - controller.battle.createdAt
|
|
] for controller in server.getOngoingBattles())
|
|
callback(battleMetadata)
|
|
|
|
spark.on 'findBattle', (format, team, altName=null) ->
|
|
console.log('find battle')
|
|
console.log(format)
|
|
console.log(team)
|
|
return unless _.isString(format)
|
|
return unless _.isObject(team)
|
|
return unless !altName || _.isString(altName)
|
|
# Note: If altName == null, then isAltOwnedBy will return true
|
|
alts.isAltOwnedBy user.name, altName, (err, valid) ->
|
|
if not valid
|
|
user.error(errors.INVALID_ALT_NAME, "You do not own this alt")
|
|
else
|
|
validationErrors = server.queuePlayer(user.name, team, format, altName)
|
|
if validationErrors.length > 0
|
|
user.error(errors.FIND_BATTLE, validationErrors)
|
|
|
|
spark.on 'cancelFindBattle', ->
|
|
server.removePlayer(user.name)
|
|
user.send("findBattleCanceled")
|
|
|
|
spark.on 'findBattleunranked', (format, team, altName=null) ->
|
|
return unless _.isString(format)
|
|
return unless _.isObject(team)
|
|
return unless !altName || _.isString(altName)
|
|
# Note: If altName == null, then isAltOwnedBy will return true
|
|
alts.isAltOwnedBy user.name, altName, (err, valid) ->
|
|
if not valid
|
|
user.error(errors.INVALID_ALT_NAME, "You do not own this alt")
|
|
else
|
|
validationErrors = server.queuePlayerunranked(user.name, team, format, altName)
|
|
if validationErrors.length > 0
|
|
user.error(errors.FIND_BATTLE, validationErrors)
|
|
|
|
spark.on 'cancelFindBattleunranked', ->
|
|
server.removePlayerunranked(user.name)
|
|
user.send("findBattleCanceledUnranked")
|
|
|
|
spark.on 'sendMove', (battleId, moveName, slot, forTurn, options, callback) ->
|
|
return unless _.isString(moveName)
|
|
return unless _.isFinite(slot)
|
|
return unless _.isFinite(forTurn)
|
|
return unless !options || _.isObject(options)
|
|
return unless _.isFunction(callback)
|
|
if battle = server.findBattle(battleId)
|
|
battle.makeMove(user.name, moveName, slot, forTurn, options)
|
|
callback()
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
spark.on 'sendSwitch', (battleId, toSlot, fromSlot, forTurn, callback) ->
|
|
return unless _.isFinite(toSlot)
|
|
return unless _.isFinite(fromSlot)
|
|
return unless _.isFinite(forTurn)
|
|
return unless _.isFunction(callback)
|
|
if battle = server.findBattle(battleId)
|
|
battle.makeSwitch(user.name, toSlot, fromSlot, forTurn)
|
|
callback()
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
spark.on 'sendCancelAction', (battleId, forTurn) ->
|
|
return unless _.isFinite(forTurn)
|
|
if battle = server.findBattle(battleId)
|
|
battle.undoCompletedRequest(user.name, forTurn)
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
spark.on 'arrangeTeam', (battleId, arrangement) ->
|
|
return unless _.isArray(arrangement)
|
|
if battle = server.findBattle(battleId)
|
|
battle.arrangeTeam(user.name, arrangement)
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
spark.on 'spectateBattle', (battleId) ->
|
|
if battle = server.findBattle(battleId)
|
|
battle.add(spark)
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
spark.on 'forfeit', (battleId) ->
|
|
if battle = server.findBattle(battleId)
|
|
battle.forfeit(user.name)
|
|
else
|
|
user.error(errors.BATTLE_DNE, battleId)
|
|
|
|
battleSearch = ->
|
|
server.beginBattles (err, battleIds) ->
|
|
if err then return
|
|
for id in battleIds
|
|
battle = server.findBattle(id)
|
|
playerIds = battle.getPlayerIds()
|
|
ratingKeys = playerIds.map((id) -> battle.getPlayer(id).ratingKey)
|
|
ratings.getRanks ratingKeys, (err, fullRanks) ->
|
|
ranks = _.compact(fullRanks)
|
|
return unless ranks.length == fullRanks.length
|
|
if 1 <= Math.max(ranks...) <= MAX_RANK_DISPLAYED
|
|
playerNames = battle.getPlayerNames()
|
|
playerNames = playerNames.map((p, i) -> "#{p} (Rank ##{ranks[i]})")
|
|
message = """A high-level match is being played!
|
|
<span class="fake_link spectate" data-battle-id="#{id}">
|
|
#{playerNames.join(" vs. ")}</span>!"""
|
|
lobby.message(message)
|
|
setTimeout(battleSearch, 5 * 1000)
|
|
|
|
battleSearchUnranked = ->
|
|
server.beginBattlesunranked (err, battleIds) ->
|
|
if err then return
|
|
for id in battleIds
|
|
battle = server.findBattle(id)
|
|
playerIds = battle.getPlayerIds()
|
|
ratingKeys = playerIds.map((id) -> battle.getPlayer(id).ratingKey)
|
|
ratings.getRanks ratingKeys, (err, fullRanks) ->
|
|
ranks = _.compact(fullRanks)
|
|
setTimeout(battleSearchUnranked, 5 * 1000)
|
|
|
|
|
|
battleSearch()
|
|
battleSearchUnranked()
|
|
|
|
httpServer.listen(port)
|
|
|
|
primus
|