mirror of
https://github.com/codeninjasllc/codecombat.git
synced 2024-12-12 16:51:35 -05:00
595 lines
22 KiB
CoffeeScript
595 lines
22 KiB
CoffeeScript
CocoModel = require './CocoModel'
|
|
SpriteBuilder = require 'lib/sprites/SpriteBuilder'
|
|
LevelComponent = require './LevelComponent'
|
|
CocoCollection = require 'collections/CocoCollection'
|
|
|
|
utils = require 'core/utils'
|
|
|
|
buildQueue = []
|
|
|
|
module.exports = class ThangType extends CocoModel
|
|
@className: 'ThangType'
|
|
@schema: require 'schemas/models/thang_type'
|
|
@heroes:
|
|
captain: '529ec584c423d4e83b000014'
|
|
knight: '529ffbf1cf1818f2be000001'
|
|
samurai: '53e12be0d042f23505c3023b'
|
|
raider: '55527eb0b8abf4ba1fe9a107'
|
|
goliath: '55e1a6e876cb0948c96af9f8'
|
|
guardian: '566a058620de41290036a745'
|
|
ninja: '52fc0ed77e01835453bd8f6c'
|
|
'forest-archer': '5466d4f2417c8b48a9811e87'
|
|
trapper: '5466d449417c8b48a9811e83'
|
|
pixie: ''
|
|
assassin: '566a2202e132c81f00f38c81'
|
|
librarian: '52fbf74b7e01835453bd8d8e'
|
|
'potion-master': '52e9adf7427172ae56002172'
|
|
sorcerer: '52fd1524c7e6cf99160e7bc9'
|
|
necromancer: '55652fb3b9effa46a1f775fd'
|
|
'dark-wizard': ''
|
|
@heroClasses:
|
|
Warrior: ['captain', 'knight', 'samurai', 'raider', 'goliath', 'guardian']
|
|
Ranger: ['ninja', 'forest-archer', 'trapper', 'pixie', 'assassin']
|
|
Wizard: ['librarian', 'potion-master', 'sorcerer', 'necromancer', 'dark-wizard']
|
|
@items:
|
|
'simple-boots': '53e237bf53457600003e3f05'
|
|
urlRoot: '/db/thang.type'
|
|
building: {}
|
|
editableByArtisans: true
|
|
@defaultActions: ['idle', 'die', 'move', 'attack']
|
|
|
|
initialize: ->
|
|
super()
|
|
@building = {}
|
|
@spriteSheets = {}
|
|
|
|
## Testing memory clearing
|
|
#f = =>
|
|
# console.info 'resetting raw data'
|
|
# @unset 'raw'
|
|
# @_previousAttributes.raw = null
|
|
#setTimeout f, 40000
|
|
|
|
resetRawData: ->
|
|
@set('raw', {shapes: {}, containers: {}, animations: {}})
|
|
|
|
resetSpriteSheetCache: ->
|
|
@buildActions()
|
|
@spriteSheets = {}
|
|
@building = {}
|
|
|
|
isFullyLoaded: ->
|
|
# TODO: Come up with a better way to identify when the model doesn't have everything needed to build the sprite. ie when it's a projection without all the required data.
|
|
return @get('actions') or @get('raster') # needs one of these two things
|
|
|
|
loadRasterImage: ->
|
|
return if @loadingRaster or @loadedRaster
|
|
return unless raster = @get('raster')
|
|
@rasterImage = $("<img src='/file/#{raster}' />")
|
|
@loadingRaster = true
|
|
@rasterImage.one('load', =>
|
|
@loadingRaster = false
|
|
@loadedRaster = true
|
|
@trigger('raster-image-loaded', @))
|
|
@rasterImage.one('error', =>
|
|
@loadingRaster = false
|
|
@trigger('raster-image-load-errored', @)
|
|
)
|
|
|
|
getActions: ->
|
|
return {} unless @isFullyLoaded()
|
|
return @actions or @buildActions()
|
|
|
|
getDefaultActions: ->
|
|
actions = []
|
|
for action in _.values(@getActions())
|
|
continue unless _.any ThangType.defaultActions, (prefix) ->
|
|
_.string.startsWith(action.name, prefix)
|
|
actions.push(action)
|
|
return actions
|
|
|
|
buildActions: ->
|
|
return null unless @isFullyLoaded()
|
|
@actions = $.extend(true, {}, @get('actions'))
|
|
for name, action of @actions
|
|
action.name = name
|
|
for relatedName, relatedAction of action.relatedActions ? {}
|
|
relatedAction.name = action.name + '_' + relatedName
|
|
@actions[relatedAction.name] = relatedAction
|
|
@actions
|
|
|
|
fillOptions: (options) ->
|
|
options ?= {}
|
|
options = _.clone options
|
|
options.resolutionFactor ?= SPRITE_RESOLUTION_FACTOR
|
|
options.async ?= false
|
|
options.thang = null # Don't hold onto any bad Thang references.
|
|
options
|
|
|
|
buildSpriteSheet: (options) ->
|
|
return false unless @isFullyLoaded() and @get 'raw'
|
|
@options = @fillOptions options
|
|
key = @spriteSheetKey(@options)
|
|
if ss = @spriteSheets[key] then return ss
|
|
if @building[key]
|
|
@options = null
|
|
return key
|
|
@t0 = new Date().getTime()
|
|
@initBuild(options)
|
|
@addGeneralFrames() unless @options.portraitOnly
|
|
@addPortrait()
|
|
@building[key] = true
|
|
result = @finishBuild()
|
|
return result
|
|
|
|
initBuild: (options) ->
|
|
@buildActions() if not @actions
|
|
@vectorParser = new SpriteBuilder(@, options)
|
|
@builder = new createjs.SpriteSheetBuilder()
|
|
@builder.padding = 2
|
|
@frames = {}
|
|
|
|
addPortrait: ->
|
|
# The portrait is built very differently than the other animations, so it gets a separate function.
|
|
return unless @actions
|
|
portrait = @actions.portrait
|
|
return unless portrait
|
|
scale = portrait.scale or 1
|
|
pt = portrait.positions?.registration
|
|
rect = new createjs.Rectangle(pt?.x/scale or 0, pt?.y/scale or 0, 100/scale, 100/scale)
|
|
if portrait.animation
|
|
mc = @vectorParser.buildMovieClip portrait.animation
|
|
mc.nominalBounds = mc.frameBounds = null # override what the movie clip says on bounding
|
|
@builder.addMovieClip(mc, rect, scale)
|
|
frames = @builder._animations[portrait.animation].frames
|
|
frames = @mapFrames(portrait.frames, frames[0]) if portrait.frames?
|
|
@builder.addAnimation 'portrait', frames, true
|
|
else if portrait.container
|
|
s = @vectorParser.buildContainerFromStore(portrait.container)
|
|
frame = @builder.addFrame(s, rect, scale)
|
|
@builder.addAnimation 'portrait', [frame], false
|
|
|
|
addGeneralFrames: ->
|
|
framesMap = {}
|
|
for animation in @requiredRawAnimations()
|
|
name = animation.animation
|
|
mc = @vectorParser.buildMovieClip name
|
|
continue unless mc
|
|
@builder.addMovieClip mc, null, animation.scale * @options.resolutionFactor
|
|
framesMap[animation.scale + '_' + name] = @builder._animations[name].frames
|
|
|
|
for name, action of @actions when action.animation
|
|
continue if name is 'portrait'
|
|
scale = action.scale ? @get('scale') ? 1
|
|
frames = framesMap[scale + '_' + action.animation]
|
|
continue unless frames
|
|
frames = @mapFrames(action.frames, frames[0]) if action.frames?
|
|
next = true
|
|
next = action.goesTo if action.goesTo
|
|
next = false if action.loops is false
|
|
@builder.addAnimation name, frames, next
|
|
|
|
for name, action of @actions when action.container and not action.animation
|
|
continue if name is 'portrait'
|
|
scale = @options.resolutionFactor * (action.scale or @get('scale') or 1)
|
|
s = @vectorParser.buildContainerFromStore(action.container)
|
|
continue unless s
|
|
frame = @builder.addFrame(s, s.bounds, scale)
|
|
@builder.addAnimation name, [frame], false
|
|
|
|
requiredRawAnimations: ->
|
|
required = []
|
|
for name, action of @get('actions')
|
|
continue if name is 'portrait'
|
|
allActions = [action].concat(_.values (action.relatedActions ? {}))
|
|
for a in allActions when a.animation
|
|
scale = if name is 'portrait' then a.scale or 1 else a.scale or @get('scale') or 1
|
|
animation = {animation: a.animation, scale: scale}
|
|
animation.portrait = name is 'portrait'
|
|
unless _.find(required, (r) -> _.isEqual r, animation)
|
|
required.push animation
|
|
required
|
|
|
|
mapFrames: (frames, frameOffset) ->
|
|
return frames unless _.isString(frames) # don't accidentally do this again
|
|
(parseInt(f, 10) + frameOffset for f in frames.split(','))
|
|
|
|
finishBuild: ->
|
|
return if _.isEmpty(@builder._animations)
|
|
key = @spriteSheetKey(@options)
|
|
spriteSheet = null
|
|
if @options.async
|
|
buildQueue.push @builder
|
|
@builder.t0 = new Date().getTime()
|
|
@builder.buildAsync() unless buildQueue.length > 1
|
|
@builder.on 'complete', @onBuildSpriteSheetComplete, @, true, [@builder, key, @options]
|
|
@builder = null
|
|
return key
|
|
spriteSheet = @builder.build()
|
|
@logBuild @t0, false, @options.portraitOnly
|
|
@spriteSheets[key] = spriteSheet
|
|
@building[key] = false
|
|
@builder = null
|
|
@options = null
|
|
spriteSheet
|
|
|
|
onBuildSpriteSheetComplete: (e, data) ->
|
|
[builder, key, options] = data
|
|
@logBuild builder.t0, true, options.portraitOnly
|
|
buildQueue = buildQueue.slice(1)
|
|
buildQueue[0].t0 = new Date().getTime() if buildQueue[0]
|
|
buildQueue[0]?.buildAsync()
|
|
@spriteSheets[key] = e.target.spriteSheet
|
|
@building[key] = false
|
|
@trigger 'build-complete', {key: key, thangType: @}
|
|
@vectorParser = null
|
|
|
|
logBuild: (startTime, async, portrait) ->
|
|
kind = if async then 'Async' else 'Sync '
|
|
portrait = if portrait then '(Portrait)' else ''
|
|
name = _.string.rpad @get('name'), 20
|
|
time = _.string.lpad '' + new Date().getTime() - startTime, 6
|
|
console.debug "Built sheet: #{name} #{time}ms #{kind} #{portrait}"
|
|
|
|
spriteSheetKey: (options) ->
|
|
colorConfigs = []
|
|
for groupName, config of options.colorConfig or {}
|
|
colorConfigs.push "#{groupName}:#{config.hue}|#{config.saturation}|#{config.lightness}"
|
|
colorConfigs = colorConfigs.join ','
|
|
portraitOnly = !!options.portraitOnly
|
|
"#{@get('name')} - #{options.resolutionFactor} - #{colorConfigs} - #{portraitOnly}"
|
|
|
|
getHeroShortName: ->
|
|
map = {
|
|
"Assassin": "Ritic"
|
|
"Captain": "Anya"
|
|
"Forest Archer": "Naria"
|
|
"Goliath": "Okar"
|
|
"Guardian": "Illia"
|
|
"Knight": "Tharin"
|
|
"Librarian": "Hushbaum"
|
|
"Necromancer": "Nalfar"
|
|
"Ninja": "Amara"
|
|
"Potion Master": "Omarn"
|
|
"Raider": "Arryn"
|
|
"Samurai": "Hattori"
|
|
"Sorcerer": "Pender"
|
|
"Trapper": "Senick"
|
|
"Champion": "Ida"
|
|
"Duelist": "Alejandro"
|
|
}
|
|
map[@get('name')]
|
|
|
|
getPortraitImage: (spriteOptionsOrKey, size=100) ->
|
|
src = @getPortraitSource(spriteOptionsOrKey, size)
|
|
return null unless src
|
|
$('<img />').attr('src', src)
|
|
|
|
getPortraitSource: (spriteOptionsOrKey, size=100) ->
|
|
return @getPortraitURL() if @get('rasterIcon') or @get('raster')
|
|
stage = @getPortraitStage(spriteOptionsOrKey, size)
|
|
stage?.toDataURL()
|
|
|
|
getPortraitStage: (spriteOptionsOrKey, size=100) ->
|
|
canvas = $("<canvas width='#{size}' height='#{size}'></canvas>")
|
|
try
|
|
stage = new createjs.Stage(canvas[0])
|
|
catch err
|
|
console.error "Error trying to create #{@get('name')} avatar stage:", err, "with window as", window
|
|
return null
|
|
return stage unless @isFullyLoaded()
|
|
key = spriteOptionsOrKey
|
|
key = if _.isString(key) then key else @spriteSheetKey(@fillOptions(key))
|
|
spriteSheet = @spriteSheets[key]
|
|
if not spriteSheet
|
|
options = if _.isPlainObject spriteOptionsOrKey then spriteOptionsOrKey else {}
|
|
options.portraitOnly = true
|
|
spriteSheet = @buildSpriteSheet(options)
|
|
return if _.isString spriteSheet
|
|
return unless spriteSheet
|
|
sprite = new createjs.Sprite(spriteSheet)
|
|
pt = @actions.portrait?.positions?.registration
|
|
sprite.regX = pt?.x or 0
|
|
sprite.regY = pt?.y or 0
|
|
sprite.framerate = @actions.portrait?.framerate ? 20
|
|
sprite.gotoAndStop 'portrait'
|
|
stage.addChild(sprite)
|
|
stage.update()
|
|
stage.startTalking = ->
|
|
sprite.gotoAndPlay 'portrait'
|
|
return # TODO: causes infinite recursion in new EaselJS
|
|
return if @tick
|
|
@tick = (e) => @update(e)
|
|
createjs.Ticker.addEventListener 'tick', @tick
|
|
stage.stopTalking = ->
|
|
sprite.gotoAndStop 'portrait'
|
|
return # TODO: just breaks in new EaselJS
|
|
@update()
|
|
createjs.Ticker.removeEventListener 'tick', @tick
|
|
@tick = null
|
|
stage
|
|
|
|
getVectorPortraitStage: (size=100) ->
|
|
return unless @actions
|
|
canvas = $("<canvas width='#{size}' height='#{size}'></canvas>")
|
|
stage = new createjs.Stage(canvas[0])
|
|
portrait = @actions.portrait
|
|
return unless portrait and (portrait.animation or portrait.container)
|
|
scale = portrait.scale or 1
|
|
|
|
vectorParser = new SpriteBuilder(@, {})
|
|
if portrait.animation
|
|
sprite = vectorParser.buildMovieClip portrait.animation
|
|
sprite.gotoAndStop(0)
|
|
else if portrait.container
|
|
sprite = vectorParser.buildContainerFromStore(portrait.container)
|
|
|
|
pt = portrait.positions?.registration
|
|
sprite.regX = pt?.x / scale or 0
|
|
sprite.regY = pt?.y / scale or 0
|
|
sprite.scaleX = sprite.scaleY = scale * size / 100
|
|
stage.addChild(sprite)
|
|
stage.update()
|
|
stage
|
|
|
|
uploadGenericPortrait: (callback, src) ->
|
|
src ?= @getPortraitSource()
|
|
return callback?() unless src and _.string.startsWith src, 'data:'
|
|
src = src.replace('data:image/png;base64,', '').replace(/\ /g, '+')
|
|
body =
|
|
filename: 'portrait.png'
|
|
mimetype: 'image/png'
|
|
path: "db/thang.type/#{@get('original')}"
|
|
b64png: src
|
|
force: 'true'
|
|
$.ajax('/file', {type: 'POST', data: body, success: callback or @onFileUploaded})
|
|
|
|
onFileUploaded: =>
|
|
console.log 'Image uploaded'
|
|
|
|
@loadUniversalWizard: ->
|
|
return @wizardType if @wizardType
|
|
wizOriginal = '52a00d55cf1818f2be00000b'
|
|
url = "/db/thang.type/#{wizOriginal}/version"
|
|
@wizardType = new module.exports()
|
|
@wizardType.url = -> url
|
|
@wizardType.fetch()
|
|
@wizardType
|
|
|
|
getPortraitURL: ->
|
|
if iconURL = @get('rasterIcon')
|
|
return "/file/#{iconURL}"
|
|
if rasterURL = @get('raster')
|
|
return "/file/#{rasterURL}"
|
|
"/file/db/thang.type/#{@get('original')}/portrait.png"
|
|
|
|
# Item functions
|
|
|
|
getAllowedSlots: ->
|
|
itemComponentRef = _.find(
|
|
@get('components') or [],
|
|
(compRef) -> compRef.original is LevelComponent.ItemID)
|
|
return itemComponentRef?.config?.slots or ['right-hand'] # ['right-hand'] is default
|
|
|
|
getAllowedHeroClasses: ->
|
|
return [heroClass] if heroClass = @get 'heroClass'
|
|
['Warrior', 'Ranger', 'Wizard']
|
|
|
|
getHeroStats: ->
|
|
# Translate from raw hero properties into appropriate display values for the PlayHeroesModal.
|
|
# Adapted from https://docs.google.com/a/codecombat.com/spreadsheets/d/1BGI1bzT4xHvWA81aeyIaCKWWw9zxn7-MwDdydmB5vw4/edit#gid=809922675
|
|
return unless heroClass = @get('heroClass')
|
|
components = @get('components') or []
|
|
unless equipsConfig = _.find(components, original: LevelComponent.EquipsID)?.config
|
|
return console.warn @get('name'), 'is not an equipping hero, but you are asking for its hero stats. (Did you project away components?)'
|
|
unless movesConfig = _.find(components, original: LevelComponent.MovesID)?.config
|
|
return console.warn @get('name'), 'is not a moving hero, but you are asking for its hero stats.'
|
|
unless programmableConfig = _.find(components, original: LevelComponent.ProgrammableID)?.config
|
|
return console.warn @get('name'), 'is not a Programmable hero, but you are asking for its hero stats.'
|
|
@classStatAverages ?=
|
|
attack: {Warrior: 7.5, Ranger: 5, Wizard: 2.5}
|
|
health: {Warrior: 7.5, Ranger: 5, Wizard: 3.5}
|
|
stats = {}
|
|
rawNumbers = attack: equipsConfig.attackDamageFactor ? 1, health: equipsConfig.maxHealthFactor ? 1, speed: movesConfig.maxSpeed
|
|
for prop in ['attack', 'health']
|
|
stat = rawNumbers[prop]
|
|
if stat < 1
|
|
classSpecificScore = 10 - 5 / stat
|
|
else
|
|
classSpecificScore = stat * 5
|
|
classAverage = @classStatAverages[prop][@get('heroClass')]
|
|
stats[prop] =
|
|
relative: Math.round(2 * ((classAverage - 2.5) + classSpecificScore / 2)) / 2 / 10
|
|
absolute: stat
|
|
pieces = ($.i18n.t "choose_hero.#{prop}_#{num}" for num in [1 .. 3])
|
|
percent = Math.round(stat * 100) + '%'
|
|
className = $.i18n.t "general.#{_.string.slugify @get('heroClass')}"
|
|
stats[prop].description = [pieces[0], percent, pieces[1], className, pieces[2]].join ' '
|
|
|
|
minSpeed = 4
|
|
maxSpeed = 16
|
|
speedRange = maxSpeed - minSpeed
|
|
speedPoints = rawNumbers.speed - minSpeed
|
|
stats.speed =
|
|
relative: Math.round(20 * speedPoints / speedRange) / 2 / 10
|
|
absolute: rawNumbers.speed
|
|
description: "#{$.i18n.t 'choose_hero.speed_1'} #{rawNumbers.speed} #{$.i18n.t 'choose_hero.speed_2'}"
|
|
|
|
stats.skills = (_.string.titleize(_.string.humanize(skill)) for skill in programmableConfig.programmableProperties when skill isnt 'say' and not /(Range|Pos|Radius|Damage)$/.test(skill))
|
|
|
|
stats
|
|
|
|
getFrontFacingStats: ->
|
|
components = @get('components') or []
|
|
unless itemConfig = _.find(components, original: LevelComponent.ItemID)?.config
|
|
console.warn @get('name'), 'is not an item, but you are asking for its stats.'
|
|
return props: [], stats: {}
|
|
stats = {}
|
|
props = itemConfig.programmableProperties ? []
|
|
props = props.concat itemConfig.moreProgrammableProperties ? []
|
|
props = _.without props, 'canCast', 'spellNames', 'spells'
|
|
for stat, modifiers of itemConfig.stats ? {}
|
|
stats[stat] = @formatStatDisplay stat, modifiers
|
|
for stat in itemConfig.extraHUDProperties ? []
|
|
stats[stat] ?= null # Find it in the other Components.
|
|
for component in components
|
|
continue unless config = component.config
|
|
for stat, value of stats when not value?
|
|
value = config[stat]
|
|
continue unless value?
|
|
stats[stat] = @formatStatDisplay stat, setTo: value
|
|
if stat is 'attackDamage'
|
|
dps = (value / (config.cooldown or 0.5)).toFixed(1)
|
|
stats[stat].display += " (#{dps} DPS)"
|
|
if config.programmableSnippets
|
|
props = props.concat config.programmableSnippets
|
|
for stat, value of stats when not value?
|
|
stats[stat] = name: stat, display: '???'
|
|
statKeys = _.keys(stats)
|
|
statKeys.sort()
|
|
props.sort()
|
|
sortedStats = {}
|
|
sortedStats[key] = stats[key] for key in statKeys
|
|
props: props, stats: sortedStats
|
|
|
|
formatStatDisplay: (name, modifiers) ->
|
|
i18nKey = {
|
|
maxHealth: 'health'
|
|
maxSpeed: 'speed'
|
|
healthReplenishRate: 'regeneration'
|
|
attackDamage: 'attack'
|
|
attackRange: 'range'
|
|
shieldDefenseFactor: 'blocks'
|
|
visualRange: 'range'
|
|
throwDamage: 'attack'
|
|
throwRange: 'range'
|
|
bashDamage: 'attack'
|
|
backstabDamage: 'backstab'
|
|
}[name]
|
|
|
|
if i18nKey
|
|
name = $.i18n.t 'choose_hero.' + i18nKey
|
|
matchedShortName = true
|
|
else
|
|
name = _.string.humanize name
|
|
matchedShortName = false
|
|
|
|
format = ''
|
|
format = 'm' if /(range|radius|distance|vision)$/i.test name
|
|
format ||= 's' if /cooldown$/i.test name
|
|
format ||= 'm/s' if /speed$/i.test name
|
|
format ||= '/s' if /(regeneration| rate)$/i.test name
|
|
value = modifiers.setTo
|
|
if /(blocks)$/i.test name
|
|
format ||= '%'
|
|
value = (value*100).toFixed(1)
|
|
value = value.join ', ' if _.isArray value
|
|
display = []
|
|
display.push "#{value}#{format}" if value?
|
|
display.push "+#{modifiers.addend}#{format}" if modifiers.addend > 0
|
|
display.push "#{modifiers.addend}#{format}" if modifiers.addend < 0
|
|
display.push "x#{modifiers.factor}" if modifiers.factor? and modifiers.factor isnt 1
|
|
display = display.join ', '
|
|
display = display.replace /9001m?/, 'Infinity'
|
|
name: name, display: display, matchedShortName: matchedShortName
|
|
|
|
isSilhouettedItem: ->
|
|
return console.error "Trying to determine whether #{@get('name')} should be a silhouetted item, but it has no gem cost." unless @get('gems')? or @get('tier')?
|
|
console.info "Add (or make sure you have fetched) a tier for #{@get('name')} to more accurately determine whether it is silhouetted." unless @get('tier')?
|
|
tier = @get 'tier'
|
|
if tier?
|
|
return @levelRequiredForItem() > me.level()
|
|
points = me.get('points')
|
|
expectedTotalGems = (points ? 0) * 1.5 # Not actually true, but roughly kinda close for tier 0, kinda tier 1
|
|
@get('gems') > (100 + expectedTotalGems) * 1.2
|
|
|
|
levelRequiredForItem: ->
|
|
return console.error "Trying to determine what level is required for #{@get('name')}, but it has no tier." unless @get('tier')?
|
|
itemTier = @get 'tier'
|
|
playerTier = itemTier / 2.5
|
|
playerLevel = me.constructor.levelForTier playerTier
|
|
#console.log 'Level required for', @get('name'), 'is', playerLevel, 'player tier', playerTier, 'because it is itemTier', itemTier, 'which is normally level', me.constructor.levelForTier(itemTier)
|
|
playerLevel
|
|
|
|
getContainersForAnimation: (animation, action) ->
|
|
rawAnimation = @get('raw').animations[animation]
|
|
if not rawAnimation
|
|
console.error 'thang type', @get('name'), 'is missing animation', animation, 'from action', action
|
|
containers = rawAnimation.containers
|
|
for animation in @get('raw').animations[animation].animations
|
|
containers = containers.concat(@getContainersForAnimation(animation.gn, action))
|
|
return containers
|
|
|
|
getContainersForActions: (actionNames) ->
|
|
containersToRender = {}
|
|
actions = @getActions()
|
|
for actionName in actionNames
|
|
action = _.find(actions, {name: actionName})
|
|
if action.container
|
|
containersToRender[action.container] = true
|
|
else if action.animation
|
|
animationContainers = @getContainersForAnimation(action.animation, action)
|
|
containersToRender[container.gn] = true for container in animationContainers
|
|
return _.keys(containersToRender)
|
|
|
|
nextForAction: (action) ->
|
|
next = true
|
|
next = action.goesTo if action.goesTo
|
|
next = false if action.loops is false
|
|
return next
|
|
|
|
initPrerenderedSpriteSheets: ->
|
|
return if @prerenderedSpriteSheets or not data = @get('prerenderedSpriteSheetData')
|
|
# creates a collection of prerendered sprite sheets
|
|
@prerenderedSpriteSheets = new PrerenderedSpriteSheets(data)
|
|
|
|
getPrerenderedSpriteSheet: (colorConfig, defaultSpriteType) ->
|
|
return unless @prerenderedSpriteSheets
|
|
spriteType = @get('spriteType') or defaultSpriteType
|
|
@prerenderedSpriteSheets.find (pss) ->
|
|
return false if pss.get('spriteType') isnt spriteType
|
|
otherColorConfig = pss.get('colorConfig')
|
|
return true if _.isEmpty(colorConfig) and _.isEmpty(otherColorConfig)
|
|
getHue = (config) -> _.result(_.result(config, 'team'), 'hue')
|
|
return getHue(colorConfig) is getHue(otherColorConfig)
|
|
|
|
getPrerenderedSpriteSheetToLoad: ->
|
|
return unless @prerenderedSpriteSheets
|
|
@prerenderedSpriteSheets.find (pss) -> pss.needToLoad and not pss.loadedImage
|
|
|
|
|
|
class PrerenderedSpriteSheet extends CocoModel
|
|
@className: 'PrerenderedSpriteSheet'
|
|
|
|
loadImage: ->
|
|
return false if @loadingImage or @loadedImage
|
|
return false unless imageURL = @get('image')
|
|
@image = $("<img src='/file/#{imageURL}' />")
|
|
@loadingImage = true
|
|
@image.one('load', =>
|
|
@loadingImage = false
|
|
@loadedImage = true
|
|
@buildSpriteSheet()
|
|
@trigger('image-loaded', @))
|
|
@image.one('error', =>
|
|
@loadingImage = false
|
|
@trigger('image-load-error', @)
|
|
)
|
|
return true
|
|
|
|
buildSpriteSheet: ->
|
|
@spriteSheet = new createjs.SpriteSheet({
|
|
images: [@image[0]],
|
|
frames: @get('frames')
|
|
animations: @get('animations')
|
|
})
|
|
|
|
markToLoad: -> @needToLoad = true
|
|
|
|
needToLoad: false
|
|
loadedImage: false
|
|
loadingImage: false
|
|
|
|
|
|
class PrerenderedSpriteSheets extends CocoCollection
|
|
model: PrerenderedSpriteSheet
|