constructor(/* basin, */data){

// this.basin = basin instanceof Basin && basin;

let opts;

if(data && !(data instanceof LoadData)) opts = data;

else opts = {};

this.displayName = opts.displayName;

this.measure = opts.measure || SCALE_MEASURE_ONE_MIN_KNOTS; // 0 = 1-minute wind speed; 2 = pressure (10-minute wind speed not yet implemented)

this.classifications = [];

let cData;

if(opts instanceof Array) cData = opts;

else if(opts.classifications instanceof Array) cData = opts.classifications;

if(cData){

for(let c of cData){

let clsn = {};

clsn.threshold = c.threshold;

if(clsn.threshold===undefined){

if(this.measure===SCALE_MEASURE_MILLIBARS) clsn.threshold = 1000;

else clsn.threshold = 35;

}

clsn.color = c.color===undefined ? 'white' : c.color;

clsn.subtropicalColor = c.subtropicalColor;

clsn.symbol = c.symbol===undefined ? 'C' : c.symbol;

clsn.arms = c.arms===undefined ? 2 : c.arms;

clsn.subtropicalSymbol = c.subtropicalSymbol;

clsn.stormNom = c.stormNom;

clsn.subtropicalStormNom = c.subtropicalStormNom;

clsn.stat = c.stat;

clsn.cName = c.cName;

this.classifications.push(clsn);

}

}

this.flavorValue = 0;

this.flavorDisplayNames = opts.flavorDisplayNames || [];

// numbering/naming thresholds may be overridden by DesignationSystem

this.numberingThreshold = opts.numberingThreshold===undefined ? 0 : opts.numberingThreshold;

this.namingThreshold = opts.namingThreshold===undefined ? 1 : opts.namingThreshold;

if(data instanceof LoadData) this.load(data);

}

get(stormData){

if(stormData instanceof StormData){

let m;

let c = 0;

if(this.measure===SCALE_MEASURE_MILLIBARS || this.measure===SCALE_MEASURE_INHG){ // pressure

m = stormData.pressure; // millibars by default

if(this.measure===SCALE_MEASURE_INHG) m = mbToInHg(m);

while(c+1<this.classifications.length && m<=this.classifications[c+1].threshold) c++;

}else{ // wind speed

m = stormData.windSpeed; // 1-minute knots by default

if(this.measure===SCALE_MEASURE_TEN_MIN_KNOTS || this.measure===SCALE_MEASURE_TEN_MIN_MPH || this.measure===SCALE_MEASURE_TEN_MIN_KMH) m = oneMinToTenMin(m); // one-minute to ten-minute wind conversion

if(this.measure===SCALE_MEASURE_ONE_MIN_MPH || this.measure===SCALE_MEASURE_TEN_MIN_MPH) m = ktsToMph(m); // knots-to-mph conversion

if(this.measure===SCALE_MEASURE_ONE_MIN_KMH || this.measure===SCALE_MEASURE_TEN_MIN_KMH) m = ktsToKmh(m); // knots-to-km/h conversion

while(c+1<this.classifications.length && m>=this.classifications[c+1].threshold) c++;

}

return c;

}

}

getColor(){

let c;

let subtropical;

if(arguments[0] instanceof StormData){

if(arguments[0].type===EXTROP) return COLORS.storm[EXTROP];

if(arguments[0].type===TROPWAVE) return COLORS.storm[TROPWAVE];

c = this.get(arguments[0]);

subtropical = arguments[0].type===SUBTROP;

}else{

c = arguments[0];

subtropical = arguments[1];

}

if(this.classifications.length<1) return 'white';

while(!this.classifications[c].color && c>0) c--;

let clsn = this.classifications[c];

let color;

if(subtropical && clsn.subtropicalColor) color = clsn.subtropicalColor;

else color = clsn.color;

if(typeof color === 'string' && color.charAt(0) === '$')

return COLOR_SCHEMES[simSettings.colorScheme].values[color.slice(1)];

else

return color;

}

getIcon(){

let c;

let subtropical;

let color;

if(arguments[0] instanceof StormData){

c = this.get(arguments[0]);

subtropical = arguments[0].type===SUBTROP;

color = this.getColor(arguments[0]);

}else{

c = arguments[0];

subtropical = arguments[1];

color = this.getColor(c,subtropical);

}

if(this.classifications.length<1) return {symbol: subtropical ? 'SC' : 'C', arms: 2, color: 'white'};

while(!this.classifications[c].symbol && c>0) c--;

let clsn = this.classifications[c];

let symbol;

let fetch = sym=>{

if(sym instanceof Array) return sym[this.flavorValue];

return sym;

};

if(subtropical){

if(clsn.subtropicalSymbol) symbol = fetch(clsn.subtropicalSymbol);

else symbol = 'S' + fetch(clsn.symbol);

}else symbol = fetch(clsn.symbol);

let arms = clsn.arms;

return {symbol, arms, color};

}

getStormNom(){

let c;

let subtropical;

if(arguments[0] instanceof StormData){

c = this.get(arguments[0]);

subtropical = arguments[0].type===SUBTROP;

}else{

c = arguments[0];

subtropical = arguments[1];

}

if(this.classifications.length<1) return subtropical ? 'Subtropical Cyclone' : 'Tropical Cyclone';

while(!this.classifications[c].stormNom && c>0) c--;

let clsn = this.classifications[c];

let fetch = n=>{

if(n instanceof Array) return n[this.flavorValue];

return n;

};

if(subtropical){

if(clsn.subtropicalStormNom) return fetch(clsn.subtropicalStormNom);

if(clsn.stormNom) return 'Subtropical ' + fetch(clsn.stormNom);

return 'Subtropical Cyclone';

}

if(clsn.stormNom) return fetch(clsn.stormNom);

return 'Tropical Cyclone';

}

getClassificationName(){

let c;

if(arguments[0] instanceof StormData) c = this.get(arguments[0]);

else c = arguments[0];

if(this.classifications.length<1) return 'Cyclone';

if(this.classifications[c].cName) return this.classifications[c].cName;

return c + '';

}

*statDisplay(){

for(let i=0;i<this.classifications.length;i++){

let clsn = this.classifications[i];

if(clsn.stat){

if(clsn.stat instanceof Array && clsn.stat[this.flavorValue]) yield {statName: clsn.stat[this.flavorValue], cNumber: i};

else if(typeof clsn.stat === 'string') yield {statName: clsn.stat, cNumber: i};

}

}

}

flavor(v){

if(typeof v === 'number'){

this.flavorValue = v;

return this;

}

return this.flavorValue;

}

clone(){

let newScale = new Scale();

for(let p of [

'displayName',

'measure',

'flavorValue',

'numberingThreshold',

'namingThreshold'

]) newScale[p] = this[p];

for(let p of [

'classifications',

'flavorDisplayNames'

]) newScale[p] = JSON.parse(JSON.stringify(this[p]));

return newScale;

}

save(){

let d = {};

for(let p of [

'displayName',

'measure',

'classifications',

'flavorValue',

'flavorDisplayNames',

'numberingThreshold',

'namingThreshold'

]) d[p] = this[p];

return d;

}

load(data){

if(data instanceof LoadData){

let d = data.value;

for(let p of [

'displayName',

'measure',

'classifications',

'flavorValue',

'flavorDisplayNames'

]) this[p] = d[p];

if(d.numberingThreshold !== undefined)

this.numberingThreshold = d.numberingThreshold;

if(d.namingThreshold !== undefined)

this.namingThreshold = d.namingThreshold;

if(d.colorSchemeValue !== undefined){

for(let c of this.classifications){

if(c.color instanceof Array)

c.color = c.color[d.colorSchemeValue];

}

}

}

}

static convertOldValue(v){ // converts pre-v0.2 (extended) Saffir-Simpson values to Scale.extendedSaffirSimpson values

if(v<5) return v+1;

return v+2;

}